op-geth
diff:
ignored:
+6747
-24898
+9896
-1549
This is an overview of the changes in op-geth,
a fork of go-ethereum, part of the OP-stack.
The OP-stack architecture is modular, following the Consensus/Execution split of post-Merge Ethereum L1:
op-nodeimplements most rollup-specific functionality as Consensus-Layer, similar to a L1 beacon-node.op-gethimplements the Execution-Layer, with minimal changes for a secure Ethereum-equivalent application environment.
Related op-stack specifications:
Core modifications
+1917
-377
State-transition modifications
+1118
-85
Deposit Transaction type
+206
-8
The Bedrock upgrade introduces a Deposit transaction-type (0x7E) to enable both users and the
rollup system itself to change the L2 state based on L1 events and system rules as
specified.
diff --git go-ethereum/core/types/deposit_tx.go op-geth/core/types/deposit_tx.go
new file mode 100644
index 0000000000000000000000000000000000000000..15a4f2b6454feaeebf85129a66e1cfcdf8c84cdc
--- /dev/null
+++ op-geth/core/types/deposit_tx.go
@@ -0,0 +1,103 @@
+// Copyright 2021 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package types
+
+import (
+ "bytes"
+ "math/big"
+
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/rlp"
+)
+
+const DepositTxType = 0x7E
+
+type DepositTx struct {
+ // SourceHash uniquely identifies the source of the deposit
+ SourceHash common.Hash
+ // From is exposed through the types.Signer, not through TxData
+ From common.Address
+ // nil means contract creation
+ To *common.Address `rlp:"nil"`
+ // Mint is minted on L2, locked on L1, nil if no minting.
+ Mint *big.Int `rlp:"nil"`
+ // Value is transferred from L2 balance, executed after Mint (if any)
+ Value *big.Int
+ // gas limit
+ Gas uint64
+ // Field indicating if this transaction is exempt from the L2 gas limit.
+ IsSystemTransaction bool
+ // Normal Tx data
+ Data []byte
+}
+
+// copy creates a deep copy of the transaction data and initializes all fields.
+func (tx *DepositTx) copy() TxData {
+ cpy := &DepositTx{
+ SourceHash: tx.SourceHash,
+ From: tx.From,
+ To: copyAddressPtr(tx.To),
+ Mint: nil,
+ Value: new(big.Int),
+ Gas: tx.Gas,
+ IsSystemTransaction: tx.IsSystemTransaction,
+ Data: common.CopyBytes(tx.Data),
+ }
+ if tx.Mint != nil {
+ cpy.Mint = new(big.Int).Set(tx.Mint)
+ }
+ if tx.Value != nil {
+ cpy.Value.Set(tx.Value)
+ }
+ return cpy
+}
+
+// accessors for innerTx.
+func (tx *DepositTx) txType() byte { return DepositTxType }
+func (tx *DepositTx) chainID() *big.Int { return common.Big0 }
+func (tx *DepositTx) accessList() AccessList { return nil }
+func (tx *DepositTx) data() []byte { return tx.Data }
+func (tx *DepositTx) gas() uint64 { return tx.Gas }
+func (tx *DepositTx) gasFeeCap() *big.Int { return new(big.Int) }
+func (tx *DepositTx) gasTipCap() *big.Int { return new(big.Int) }
+func (tx *DepositTx) gasPrice() *big.Int { return new(big.Int) }
+func (tx *DepositTx) value() *big.Int { return tx.Value }
+func (tx *DepositTx) nonce() uint64 { return 0 }
+func (tx *DepositTx) to() *common.Address { return tx.To }
+func (tx *DepositTx) isSystemTx() bool { return tx.IsSystemTransaction }
+
+func (tx *DepositTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int {
+ return dst.Set(new(big.Int))
+}
+
+func (tx *DepositTx) effectiveNonce() *uint64 { return nil }
+
+func (tx *DepositTx) rawSignatureValues() (v, r, s *big.Int) {
+ return common.Big0, common.Big0, common.Big0
+}
+
+func (tx *DepositTx) setSignatureValues(chainID, v, r, s *big.Int) {
+ // this is a noop for deposit transactions
+}
+
+func (tx *DepositTx) encode(b *bytes.Buffer) error {
+ return rlp.Encode(b, tx)
+}
+
+func (tx *DepositTx) decode(input []byte) error {
+ return rlp.DecodeBytes(input, tx)
+}
diff --git go-ethereum/core/types/transaction_marshalling.go op-geth/core/types/transaction_marshalling.go
index 4d5b2bcdd4ce375d6c9896cbd321ff7949b071fb..07e59dd7435e1afadfae60c2f0d4bbc73bd996ea 100644
--- go-ethereum/core/types/transaction_marshalling.go
+++ op-geth/core/types/transaction_marshalling.go
@@ -19,12 +19,14 @@
import (
"encoding/json"
"errors"
+ "io"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/rlp"
)
// txJSON is the JSON representation of transactions.
@@ -47,6 +49,12 @@ V *hexutil.Big `json:"v"`
R *hexutil.Big `json:"r"`
S *hexutil.Big `json:"s"`
YParity *hexutil.Uint64 `json:"yParity,omitempty"`
+
+ // Deposit transaction fields
+ SourceHash *common.Hash `json:"sourceHash,omitempty"`
+ From *common.Address `json:"from,omitempty"`
+ Mint *hexutil.Big `json:"mint,omitempty"`
+ IsSystemTx *bool `json:"isSystemTx,omitempty"`
// Blob transaction sidecar encoding:
Blobs []kzg4844.Blob `json:"blobs,omitempty"`
@@ -153,6 +161,19 @@ enc.Blobs = itx.Sidecar.Blobs
enc.Commitments = itx.Sidecar.Commitments
enc.Proofs = itx.Sidecar.Proofs
}
+
+ case *DepositTx:
+ enc.Gas = (*hexutil.Uint64)(&itx.Gas)
+ enc.Value = (*hexutil.Big)(itx.Value)
+ enc.Input = (*hexutil.Bytes)(&itx.Data)
+ enc.To = tx.To()
+ enc.SourceHash = &itx.SourceHash
+ enc.From = &itx.From
+ if itx.Mint != nil {
+ enc.Mint = (*hexutil.Big)(itx.Mint)
+ }
+ enc.IsSystemTx = &itx.IsSystemTransaction
+ // other fields will show up as null.
}
return json.Marshal(&enc)
}
@@ -409,6 +430,54 @@ return err
}
}
+ case DepositTxType:
+ if dec.AccessList != nil || dec.MaxFeePerGas != nil ||
+ dec.MaxPriorityFeePerGas != nil {
+ return errors.New("unexpected field(s) in deposit transaction")
+ }
+ if dec.GasPrice != nil && dec.GasPrice.ToInt().Cmp(common.Big0) != 0 {
+ return errors.New("deposit transaction GasPrice must be 0")
+ }
+ if (dec.V != nil && dec.V.ToInt().Cmp(common.Big0) != 0) ||
+ (dec.R != nil && dec.R.ToInt().Cmp(common.Big0) != 0) ||
+ (dec.S != nil && dec.S.ToInt().Cmp(common.Big0) != 0) {
+ return errors.New("deposit transaction signature must be 0 or unset")
+ }
+ var itx DepositTx
+ inner = &itx
+ if dec.To != nil {
+ itx.To = dec.To
+ }
+ if dec.Gas == nil {
+ return errors.New("missing required field 'gas' for txdata")
+ }
+ itx.Gas = uint64(*dec.Gas)
+ if dec.Value == nil {
+ return errors.New("missing required field 'value' in transaction")
+ }
+ itx.Value = (*big.Int)(dec.Value)
+ // mint may be omitted or nil if there is nothing to mint.
+ itx.Mint = (*big.Int)(dec.Mint)
+ if dec.Input == nil {
+ return errors.New("missing required field 'input' in transaction")
+ }
+ itx.Data = *dec.Input
+ if dec.From == nil {
+ return errors.New("missing required field 'from' in transaction")
+ }
+ itx.From = *dec.From
+ if dec.SourceHash == nil {
+ return errors.New("missing required field 'sourceHash' in transaction")
+ }
+ itx.SourceHash = *dec.SourceHash
+ // IsSystemTx may be omitted. Defaults to false.
+ if dec.IsSystemTx != nil {
+ itx.IsSystemTransaction = *dec.IsSystemTx
+ }
+
+ if dec.Nonce != nil {
+ inner = &depositTxWithNonce{DepositTx: itx, EffectiveNonce: uint64(*dec.Nonce)}
+ }
default:
return ErrTxTypeNotSupported
}
@@ -419,3 +488,15 @@
// TODO: check hash here?
return nil
}
+
+type depositTxWithNonce struct {
+ DepositTx
+ EffectiveNonce uint64
+}
+
+// EncodeRLP ensures that RLP encoding this transaction excludes the nonce. Otherwise, the tx Hash would change
+func (tx *depositTxWithNonce) EncodeRLP(w io.Writer) error {
+ return rlp.Encode(w, tx.DepositTx)
+}
+
+func (tx *depositTxWithNonce) effectiveNonce() *uint64 { return &tx.EffectiveNonce }
diff --git go-ethereum/core/types/transaction_signing.go op-geth/core/types/transaction_signing.go
index 9e26642f753db4f0b370aef0ce84f327defbf7b7..0e2c0c0be3f7a816045b011e1c007bab59a4cffc 100644
--- go-ethereum/core/types/transaction_signing.go
+++ op-geth/core/types/transaction_signing.go
@@ -22,9 +22,9 @@ "errors"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
)
var ErrInvalidChainId = errors.New("invalid chain id for signer")
@@ -40,7 +40,7 @@ // MakeSigner returns a Signer based on the given chain config and block number.
func MakeSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint64) Signer {
var signer Signer
switch {
- case config.IsCancun(blockNumber, blockTime):
+ case config.IsCancun(blockNumber, blockTime) && !config.IsOptimism():
signer = NewCancunSigner(config.ChainID)
case config.IsLondon(blockNumber):
signer = NewLondonSigner(config.ChainID)
@@ -65,7 +65,7 @@ // Use this in transaction-handling code where the current block number is unknown. If you
// have the current block number available, use MakeSigner instead.
func LatestSigner(config *params.ChainConfig) Signer {
if config.ChainID != nil {
- if config.CancunTime != nil {
+ if config.CancunTime != nil && !config.IsOptimism() {
return NewCancunSigner(config.ChainID)
}
if config.LondonBlock != nil {
@@ -256,6 +256,14 @@ return londonSigner{eip2930Signer{NewEIP155Signer(chainId)}}
}
func (s londonSigner) Sender(tx *Transaction) (common.Address, error) {
+ if tx.Type() == DepositTxType {
+ switch tx.inner.(type) {
+ case *DepositTx:
+ return tx.inner.(*DepositTx).From, nil
+ case *depositTxWithNonce:
+ return tx.inner.(*depositTxWithNonce).From, nil
+ }
+ }
if tx.Type() != DynamicFeeTxType {
return s.eip2930Signer.Sender(tx)
}
@@ -275,6 +283,9 @@ return ok && x.chainId.Cmp(s.chainId) == 0
}
func (s londonSigner) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big.Int, err error) {
+ if tx.Type() == DepositTxType {
+ return nil, nil, nil, fmt.Errorf("deposits do not have a signature")
+ }
txdata, ok := tx.inner.(*DynamicFeeTx)
if !ok {
return s.eip2930Signer.SignatureValues(tx, sig)
@@ -292,6 +303,9 @@
// Hash returns the hash to be signed by the sender.
// It does not uniquely identify the transaction.
func (s londonSigner) Hash(tx *Transaction) common.Hash {
+ if tx.Type() == DepositTxType {
+ panic("deposits cannot be signed and do not have a signing hash")
+ }
if tx.Type() != DynamicFeeTxType {
return s.eip2930Signer.Hash(tx)
}
Transaction properties
+100
-13
The Transaction type now exposes the deposit-transaction and L1-cost properties required for the rollup.
diff --git go-ethereum/core/types/transaction.go op-geth/core/types/transaction.go
index 7d2e9d5325a642ea87fe388f59f592a264e287f8..043310ae8236e3ee63a82853fff75ef762d2ab31 100644
--- go-ethereum/core/types/transaction.go
+++ op-geth/core/types/transaction.go
@@ -25,10 +25,11 @@ "math/big"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
)
var (
@@ -60,6 +61,9 @@ // caches
hash atomic.Value
size atomic.Value
from atomic.Value
+
+ // cache of details to compute the data availability fee
+ rollupCostData atomic.Value
}
// NewTx creates a new transaction.
@@ -86,6 +90,7 @@ gasFeeCap() *big.Int
value() *big.Int
nonce() uint64
to() *common.Address
+ isSystemTx() bool
rawSignatureValues() (v, r, s *big.Int)
setSignatureValues(chainID, v, r, s *big.Int)
@@ -206,6 +211,8 @@ case DynamicFeeTxType:
inner = new(DynamicFeeTx)
case BlobTxType:
inner = new(BlobTx)
+ case DepositTxType:
+ inner = new(DepositTx)
default:
return nil, ErrTxTypeNotSupported
}
@@ -303,12 +310,56 @@
// Nonce returns the sender account nonce of the transaction.
func (tx *Transaction) Nonce() uint64 { return tx.inner.nonce() }
+// EffectiveNonce returns the nonce that was actually used as part of transaction execution
+// Returns nil if the effective nonce is not known
+func (tx *Transaction) EffectiveNonce() *uint64 {
+ type txWithEffectiveNonce interface {
+ effectiveNonce() *uint64
+ }
+
+ if itx, ok := tx.inner.(txWithEffectiveNonce); ok {
+ return itx.effectiveNonce()
+ }
+ nonce := tx.inner.nonce()
+ return &nonce
+}
+
// To returns the recipient address of the transaction.
// For contract-creation transactions, To returns nil.
func (tx *Transaction) To() *common.Address {
return copyAddressPtr(tx.inner.to())
}
+// SourceHash returns the hash that uniquely identifies the source of the deposit tx,
+// e.g. a user deposit event, or a L1 info deposit included in a specific L2 block height.
+// Non-deposit transactions return a zeroed hash.
+func (tx *Transaction) SourceHash() common.Hash {
+ if dep, ok := tx.inner.(*DepositTx); ok {
+ return dep.SourceHash
+ }
+ return common.Hash{}
+}
+
+// Mint returns the ETH to mint in the deposit tx.
+// This returns nil if there is nothing to mint, or if this is not a deposit tx.
+func (tx *Transaction) Mint() *big.Int {
+ if dep, ok := tx.inner.(*DepositTx); ok {
+ return dep.Mint
+ }
+ return nil
+}
+
+// IsDepositTx returns true if the transaction is a deposit tx type.
+func (tx *Transaction) IsDepositTx() bool {
+ return tx.Type() == DepositTxType
+}
+
+// IsSystemTx returns true for deposits that are system transactions. These transactions
+// are executed in an unmetered environment & do not contribute to the block gas limit.
+func (tx *Transaction) IsSystemTx() bool {
+ return tx.inner.isSystemTx()
+}
+
// Cost returns (gas * gasPrice) + (blobGas * blobGasPrice) + value.
func (tx *Transaction) Cost() *big.Int {
total := new(big.Int).Mul(tx.GasPrice(), new(big.Int).SetUint64(tx.Gas()))
@@ -319,6 +370,23 @@ total.Add(total, tx.Value())
return total
}
+// RollupCostData caches the information needed to efficiently compute the data availability fee
+func (tx *Transaction) RollupCostData() RollupCostData {
+ if tx.Type() == DepositTxType {
+ return RollupCostData{}
+ }
+ if v := tx.rollupCostData.Load(); v != nil {
+ return v.(RollupCostData)
+ }
+ data, err := tx.MarshalBinary()
+ if err != nil { // Silent error, invalid txs will not be marshalled/unmarshalled for batch submission anyway.
+ log.Error("failed to encode tx for L1 cost computation", "err", err)
+ }
+ out := NewRollupCostData(data)
+ tx.rollupCostData.Store(out)
+ return out
+}
+
// RawSignatureValues returns the V, R, S signature values of the transaction.
// The return values should not be modified by the caller.
// The return values may be nil or zero, if the transaction is unsigned.
@@ -350,6 +418,9 @@ // EffectiveGasTip returns the effective miner gasTipCap for the given base fee.
// Note: if the effective gasTipCap is negative, this method returns both error
// the actual negative value, _and_ ErrGasFeeCapTooLow
func (tx *Transaction) EffectiveGasTip(baseFee *big.Int) (*big.Int, error) {
+ if tx.Type() == DepositTxType {
+ return new(big.Int), nil
+ }
if baseFee == nil {
return tx.GasTipCap(), nil
}
@@ -413,6 +484,18 @@ func (tx *Transaction) BlobTxSidecar() *BlobTxSidecar {
if blobtx, ok := tx.inner.(*BlobTx); ok {
return blobtx.Sidecar
}
+ return nil
+}
+
+// SetBlobTxSidecar sets the sidecar of a transaction.
+// The sidecar should match the blob-tx versioned hashes, or the transaction will be invalid.
+// This allows tools to easily re-attach blob sidecars to signed transactions that omit the sidecar.
+func (tx *Transaction) SetBlobTxSidecar(sidecar *BlobTxSidecar) error {
+ blobtx, ok := tx.inner.(*BlobTx)
+ if !ok {
+ return fmt.Errorf("not a blob tx, type = %d", tx.Type())
+ }
+ blobtx.Sidecar = sidecar
return nil
}
diff --git go-ethereum/core/types/tx_access_list.go op-geth/core/types/tx_access_list.go
index 730a77b752866afb5e6ba3d7ea8f4a5af6456d00..9dadafb35fe6698fa1c11d71309385dd4fe46e45 100644
--- go-ethereum/core/types/tx_access_list.go
+++ op-geth/core/types/tx_access_list.go
@@ -20,8 +20,8 @@ import (
"bytes"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/rlp"
)
//go:generate go run github.com/fjl/gencodec -type AccessTuple -out gen_access_tuple.go
@@ -107,6 +107,7 @@ func (tx *AccessListTx) gasFeeCap() *big.Int { return tx.GasPrice }
func (tx *AccessListTx) value() *big.Int { return tx.Value }
func (tx *AccessListTx) nonce() uint64 { return tx.Nonce }
func (tx *AccessListTx) to() *common.Address { return tx.To }
+func (tx *AccessListTx) isSystemTx() bool { return false }
func (tx *AccessListTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int {
return dst.Set(tx.GasPrice)
diff --git go-ethereum/core/types/tx_blob.go op-geth/core/types/tx_blob.go
index 25a85695efc907e24aa76cdd99f350a08082b864..2562f30fa80a18bfc50c8dbcab106400b1e13a15 100644
--- go-ethereum/core/types/tx_blob.go
+++ op-geth/core/types/tx_blob.go
@@ -21,11 +21,11 @@ "bytes"
"crypto/sha256"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
// BlobTx represents an EIP-4844 transaction.
@@ -162,6 +162,7 @@ func (tx *BlobTx) value() *big.Int { return tx.Value.ToBig() }
func (tx *BlobTx) nonce() uint64 { return tx.Nonce }
func (tx *BlobTx) to() *common.Address { tmp := tx.To; return &tmp }
func (tx *BlobTx) blobGas() uint64 { return params.BlobTxBlobGasPerBlob * uint64(len(tx.BlobHashes)) }
+func (tx *BlobTx) isSystemTx() bool { return false }
func (tx *BlobTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int {
if baseFee == nil {
diff --git go-ethereum/core/types/tx_dynamic_fee.go op-geth/core/types/tx_dynamic_fee.go
index 8b5b514fdec5b58fc8058e582a0a7c355e0ccba8..40ca3dc7490e90e11730c37ad443d384e52339c1 100644
--- go-ethereum/core/types/tx_dynamic_fee.go
+++ op-geth/core/types/tx_dynamic_fee.go
@@ -20,8 +20,8 @@ import (
"bytes"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/rlp"
)
// DynamicFeeTx represents an EIP-1559 transaction.
@@ -96,6 +96,7 @@ func (tx *DynamicFeeTx) gasPrice() *big.Int { return tx.GasFeeCap }
func (tx *DynamicFeeTx) value() *big.Int { return tx.Value }
func (tx *DynamicFeeTx) nonce() uint64 { return tx.Nonce }
func (tx *DynamicFeeTx) to() *common.Address { return tx.To }
+func (tx *DynamicFeeTx) isSystemTx() bool { return false }
func (tx *DynamicFeeTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int {
if baseFee == nil {
diff --git go-ethereum/core/types/tx_legacy.go op-geth/core/types/tx_legacy.go
index 71025b78fc060692c1d034f84b59b4cdc8e6cf65..471fc0fd19cefc8c25305863c1749cb58a62db2c 100644
--- go-ethereum/core/types/tx_legacy.go
+++ op-geth/core/types/tx_legacy.go
@@ -20,7 +20,7 @@ import (
"bytes"
"math/big"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// LegacyTx is the transaction data of the original Ethereum transactions.
@@ -103,6 +103,7 @@ func (tx *LegacyTx) gasFeeCap() *big.Int { return tx.GasPrice }
func (tx *LegacyTx) value() *big.Int { return tx.Value }
func (tx *LegacyTx) nonce() uint64 { return tx.Nonce }
func (tx *LegacyTx) to() *common.Address { return tx.To }
+func (tx *LegacyTx) isSystemTx() bool { return false }
func (tx *LegacyTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int {
return dst.Set(tx.GasPrice)
L1 cost computation
+531
-27
Transactions must pay an additional L1 cost based on the amount of rollup-data-gas they consume, estimated based on gas-price-oracle information and encoded tx size.”
diff --git go-ethereum/core/evm.go op-geth/core/evm.go
index 73f6d7bc20a09ad5e2e9ae4f4a81018a5efe1444..5ad40cd2b5570b0e1d56b9fe8e09a84489c97b8e 100644
--- go-ethereum/core/evm.go
+++ op-geth/core/evm.go
@@ -19,12 +19,13 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/params"
)
// ChainContext supports retrieving headers and consensus parameters from the
@@ -38,7 +39,7 @@ GetHeader(common.Hash, uint64) *types.Header
}
// NewEVMBlockContext creates a new context for use in the EVM.
-func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common.Address) vm.BlockContext {
+func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common.Address, config *params.ChainConfig, statedb types.StateGetter) vm.BlockContext {
var (
beneficiary common.Address
baseFee *big.Int
@@ -73,6 +74,7 @@ BaseFee: baseFee,
BlobBaseFee: blobBaseFee,
GasLimit: header.GasLimit,
Random: random,
+ L1CostFunc: types.NewL1CostFunc(config, statedb),
}
}
diff --git go-ethereum/core/state_prefetcher.go op-geth/core/state_prefetcher.go
index ff867309de302b90dc3e071e97cbe3705d34c970..c66cf225216088edc959937c760476730b5c9357 100644
--- go-ethereum/core/state_prefetcher.go
+++ op-geth/core/state_prefetcher.go
@@ -19,11 +19,11 @@
import (
"sync/atomic"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/params"
)
// statePrefetcher is a basic Prefetcher, which blindly executes a block on top
@@ -51,7 +51,7 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, cfg vm.Config, interrupt *atomic.Bool) {
var (
header = block.Header()
gaspool = new(GasPool).AddGas(block.GasLimit())
- blockContext = NewEVMBlockContext(header, p.bc, nil)
+ blockContext = NewEVMBlockContext(header, p.bc, nil, p.config, statedb)
evm = vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg)
signer = types.MakeSigner(p.config, header.Number, header.Time)
)
diff --git go-ethereum/core/state_processor.go op-geth/core/state_processor.go
index 9e32ab4e569600636e88bd8c6579771bfdb18733..8d01c6c9cded80c7dee6ec6623ef9b5518440e4e 100644
--- go-ethereum/core/state_processor.go
+++ op-geth/core/state_processor.go
@@ -21,14 +21,14 @@ "errors"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/misc"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/misc"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
)
// StateProcessor is a basic Processor, which takes care of transitioning
@@ -71,8 +71,9 @@ // Mutate the block and state according to any hard-fork specs
if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {
misc.ApplyDAOHardFork(statedb)
}
+ misc.EnsureCreate2Deployer(p.config, block.Time(), statedb)
var (
- context = NewEVMBlockContext(header, p.bc, nil)
+ context = NewEVMBlockContext(header, p.bc, nil, p.config, statedb)
vmenv = vm.NewEVM(context, vm.TxContext{}, statedb, p.config, cfg)
signer = types.MakeSigner(p.config, header.Number, header.Time)
)
@@ -109,6 +110,11 @@ // Create a new context to be used in the EVM environment.
txContext := NewEVMTxContext(msg)
evm.Reset(txContext, statedb)
+ nonce := tx.Nonce()
+ if msg.IsDepositTx && config.IsOptimismRegolith(evm.Context.Time) {
+ nonce = statedb.GetNonce(msg.From)
+ }
+
// Apply the transaction to the current state (included in the env).
result, err := ApplyMessage(evm, msg, gp)
if err != nil {
@@ -135,6 +141,17 @@ }
receipt.TxHash = tx.Hash()
receipt.GasUsed = result.UsedGas
+ if msg.IsDepositTx && config.IsOptimismRegolith(evm.Context.Time) {
+ // The actual nonce for deposit transactions is only recorded from Regolith onwards and
+ // otherwise must be nil.
+ receipt.DepositNonce = &nonce
+ // The DepositReceiptVersion for deposit transactions is only recorded from Canyon onwards
+ // and otherwise must be nil.
+ if config.IsOptimismCanyon(evm.Context.Time) {
+ receipt.DepositReceiptVersion = new(uint64)
+ *receipt.DepositReceiptVersion = types.CanyonDepositReceiptVersion
+ }
+ }
if tx.Type() == types.BlobTxType {
receipt.BlobGasUsed = uint64(len(tx.BlobHashes()) * params.BlobTxBlobGasPerBlob)
receipt.BlobGasPrice = evm.Context.BlobBaseFee
@@ -142,7 +159,7 @@ }
// If the transaction created a contract, store the creation address in the receipt.
if msg.To == nil {
- receipt.ContractAddress = crypto.CreateAddress(evm.TxContext.Origin, tx.Nonce())
+ receipt.ContractAddress = crypto.CreateAddress(evm.TxContext.Origin, nonce)
}
// Set the receipt logs and create the bloom filter.
@@ -164,7 +181,7 @@ if err != nil {
return nil, err
}
// Create a new context to be used in the EVM environment
- blockContext := NewEVMBlockContext(header, bc, author)
+ blockContext := NewEVMBlockContext(header, bc, author, config, statedb)
txContext := NewEVMTxContext(msg)
vmenv := vm.NewEVM(blockContext, txContext, statedb, config, cfg)
return applyTransaction(msg, config, gp, statedb, header.Number, header.Hash(), tx, usedGas, vmenv)
diff --git go-ethereum/core/types/rollup_cost.go op-geth/core/types/rollup_cost.go
new file mode 100644
index 0000000000000000000000000000000000000000..e07f56c32a2fc3292ebd1c83f369aa8a6000e502
--- /dev/null
+++ op-geth/core/types/rollup_cost.go
@@ -0,0 +1,473 @@
+// Copyright 2022 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package types
+
+import (
+ "bytes"
+ "encoding/binary"
+ "fmt"
+ "math/big"
+
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+)
+
+const (
+ // The two 4-byte Ecotone fee scalar values are packed into the same storage slot as the 8-byte
+ // sequence number and have the following Solidity offsets within the slot. Note that Solidity
+ // offsets correspond to the last byte of the value in the slot, counting backwards from the
+ // end of the slot. For example, The 8-byte sequence number has offset 0, and is therefore
+ // stored as big-endian format in bytes [24:32) of the slot.
+ BaseFeeScalarSlotOffset = 12 // bytes [16:20) of the slot
+ BlobBaseFeeScalarSlotOffset = 8 // bytes [20:24) of the slot
+
+ // scalarSectionStart is the beginning of the scalar values segment in the slot
+ // array. baseFeeScalar is in the first four bytes of the segment, blobBaseFeeScalar the next
+ // four.
+ scalarSectionStart = 32 - BaseFeeScalarSlotOffset - 4
+)
+
+func init() {
+ if BlobBaseFeeScalarSlotOffset != BaseFeeScalarSlotOffset-4 {
+ panic("this code assumes the scalars are at adjacent positions in the scalars slot")
+ }
+}
+
+var (
+ // BedrockL1AttributesSelector is the function selector indicating Bedrock style L1 gas
+ // attributes.
+ BedrockL1AttributesSelector = []byte{0x01, 0x5d, 0x8e, 0xb9}
+ // EcotoneL1AttributesSelector is the selector indicating Ecotone style L1 gas attributes.
+ EcotoneL1AttributesSelector = []byte{0x44, 0x0a, 0x5e, 0x20}
+
+ // L1BlockAddr is the address of the L1Block contract which stores the L1 gas attributes.
+ L1BlockAddr = common.HexToAddress("0x4200000000000000000000000000000000000015")
+
+ L1BaseFeeSlot = common.BigToHash(big.NewInt(1))
+ OverheadSlot = common.BigToHash(big.NewInt(5))
+ ScalarSlot = common.BigToHash(big.NewInt(6))
+
+ // L1BlobBaseFeeSlot was added with the Ecotone upgrade and stores the blobBaseFee L1 gas
+ // attribute.
+ L1BlobBaseFeeSlot = common.BigToHash(big.NewInt(7))
+ // L1FeeScalarsSlot as of the Ecotone upgrade stores the 32-bit basefeeScalar and
+ // blobBaseFeeScalar L1 gas attributes at offsets `BaseFeeScalarSlotOffset` and
+ // `BlobBaseFeeScalarSlotOffset` respectively.
+ L1FeeScalarsSlot = common.BigToHash(big.NewInt(3))
+
+ oneMillion = big.NewInt(1_000_000)
+ ecotoneDivisor = big.NewInt(1_000_000 * 16)
+ fjordDivisor = big.NewInt(1_000_000_000_000)
+ sixteen = big.NewInt(16)
+
+ L1CostIntercept = big.NewInt(-42_585_600)
+ L1CostFastlzCoef = big.NewInt(836_500)
+
+ MinTransactionSize = big.NewInt(100)
+ MinTransactionSizeScaled = new(big.Int).Mul(MinTransactionSize, big.NewInt(1e6))
+
+ emptyScalars = make([]byte, 8)
+)
+
+// RollupCostData is a transaction structure that caches data for quickly computing the data
+// availability costs for the transaction.
+type RollupCostData struct {
+ Zeroes, Ones uint64
+ FastLzSize uint64
+}
+
+type StateGetter interface {
+ GetState(common.Address, common.Hash) common.Hash
+}
+
+// L1CostFunc is used in the state transition to determine the data availability fee charged to the
+// sender of non-Deposit transactions. It returns nil if no data availability fee is charged.
+type L1CostFunc func(rcd RollupCostData, blockTime uint64) *big.Int
+
+// l1CostFunc is an internal version of L1CostFunc that also returns the gasUsed for use in
+// receipts.
+type l1CostFunc func(rcd RollupCostData) (fee, gasUsed *big.Int)
+
+func NewRollupCostData(data []byte) (out RollupCostData) {
+ for _, b := range data {
+ if b == 0 {
+ out.Zeroes++
+ } else {
+ out.Ones++
+ }
+ }
+ out.FastLzSize = uint64(FlzCompressLen(data))
+ return out
+}
+
+// NewL1CostFunc returns a function used for calculating data availability fees, or nil if this is
+// not an op-stack chain.
+func NewL1CostFunc(config *params.ChainConfig, statedb StateGetter) L1CostFunc {
+ if config.Optimism == nil {
+ return nil
+ }
+ forBlock := ^uint64(0)
+ var cachedFunc l1CostFunc
+ selectFunc := func(blockTime uint64) l1CostFunc {
+ if !config.IsOptimismEcotone(blockTime) {
+ return newL1CostFuncBedrock(config, statedb, blockTime)
+ }
+
+ // Note: the various state variables below are not initialized from the DB until this
+ // point to allow deposit transactions from the block to be processed first by state
+ // transition. This behavior is consensus critical!
+ l1FeeScalars := statedb.GetState(L1BlockAddr, L1FeeScalarsSlot).Bytes()
+ l1BlobBaseFee := statedb.GetState(L1BlockAddr, L1BlobBaseFeeSlot).Big()
+ l1BaseFee := statedb.GetState(L1BlockAddr, L1BaseFeeSlot).Big()
+
+ // Edge case: the very first Ecotone block requires we use the Bedrock cost
+ // function. We detect this scenario by checking if the Ecotone parameters are
+ // unset. Note here we rely on assumption that the scalar parameters are adjacent
+ // in the buffer and l1BaseFeeScalar comes first. We need to check this prior to
+ // other forks, as the first block of Fjord and Ecotone could be the same block.
+ firstEcotoneBlock := l1BlobBaseFee.BitLen() == 0 &&
+ bytes.Equal(emptyScalars, l1FeeScalars[scalarSectionStart:scalarSectionStart+8])
+ if firstEcotoneBlock {
+ log.Info("using bedrock l1 cost func for first Ecotone block", "time", blockTime)
+ return newL1CostFuncBedrock(config, statedb, blockTime)
+ }
+
+ l1BaseFeeScalar, l1BlobBaseFeeScalar := extractEcotoneFeeParams(l1FeeScalars)
+
+ if config.IsOptimismFjord(blockTime) {
+ return NewL1CostFuncFjord(
+ l1BaseFee,
+ l1BlobBaseFee,
+ l1BaseFeeScalar,
+ l1BlobBaseFeeScalar,
+ )
+ } else {
+ return newL1CostFuncEcotone(l1BaseFee, l1BlobBaseFee, l1BaseFeeScalar, l1BlobBaseFeeScalar)
+ }
+ }
+
+ return func(rollupCostData RollupCostData, blockTime uint64) *big.Int {
+ if rollupCostData == (RollupCostData{}) {
+ return nil // Do not charge if there is no rollup cost-data (e.g. RPC call or deposit).
+ }
+ if forBlock != blockTime {
+ if forBlock != ^uint64(0) {
+ // best practice is not to re-use l1 cost funcs across different blocks, but we
+ // make it work just in case.
+ log.Info("l1 cost func re-used for different L1 block", "oldTime", forBlock, "newTime", blockTime)
+ }
+ forBlock = blockTime
+ cachedFunc = selectFunc(blockTime)
+ }
+ fee, _ := cachedFunc(rollupCostData)
+ return fee
+ }
+}
+
+// newL1CostFuncBedrock returns an L1 cost function suitable for Bedrock, Regolith, and the first
+// block only of the Ecotone upgrade.
+func newL1CostFuncBedrock(config *params.ChainConfig, statedb StateGetter, blockTime uint64) l1CostFunc {
+ l1BaseFee := statedb.GetState(L1BlockAddr, L1BaseFeeSlot).Big()
+ overhead := statedb.GetState(L1BlockAddr, OverheadSlot).Big()
+ scalar := statedb.GetState(L1BlockAddr, ScalarSlot).Big()
+ isRegolith := config.IsRegolith(blockTime)
+ return newL1CostFuncBedrockHelper(l1BaseFee, overhead, scalar, isRegolith)
+}
+
+// newL1CostFuncBedrockHelper is lower level version of newL1CostFuncBedrock that expects already
+// extracted parameters
+func newL1CostFuncBedrockHelper(l1BaseFee, overhead, scalar *big.Int, isRegolith bool) l1CostFunc {
+ return func(rollupCostData RollupCostData) (fee, gasUsed *big.Int) {
+ if rollupCostData == (RollupCostData{}) {
+ return nil, nil // Do not charge if there is no rollup cost-data (e.g. RPC call or deposit)
+ }
+ gas := rollupCostData.Zeroes * params.TxDataZeroGas
+ if isRegolith {
+ gas += rollupCostData.Ones * params.TxDataNonZeroGasEIP2028
+ } else {
+ gas += (rollupCostData.Ones + 68) * params.TxDataNonZeroGasEIP2028
+ }
+ gasWithOverhead := new(big.Int).SetUint64(gas)
+ gasWithOverhead.Add(gasWithOverhead, overhead)
+ l1Cost := l1CostHelper(gasWithOverhead, l1BaseFee, scalar)
+ return l1Cost, gasWithOverhead
+ }
+}
+
+// newL1CostFuncEcotone returns an l1 cost function suitable for the Ecotone upgrade except for the
+// very first block of the upgrade.
+func newL1CostFuncEcotone(l1BaseFee, l1BlobBaseFee, l1BaseFeeScalar, l1BlobBaseFeeScalar *big.Int) l1CostFunc {
+ return func(costData RollupCostData) (fee, calldataGasUsed *big.Int) {
+ calldataGasUsed = bedrockCalldataGasUsed(costData)
+
+ // Ecotone L1 cost function:
+ //
+ // (calldataGas/16)*(l1BaseFee*16*l1BaseFeeScalar + l1BlobBaseFee*l1BlobBaseFeeScalar)/1e6
+ //
+ // We divide "calldataGas" by 16 to change from units of calldata gas to "estimated # of bytes when
+ // compressed". Known as "compressedTxSize" in the spec.
+ //
+ // Function is actually computed as follows for better precision under integer arithmetic:
+ //
+ // calldataGas*(l1BaseFee*16*l1BaseFeeScalar + l1BlobBaseFee*l1BlobBaseFeeScalar)/16e6
+
+ calldataCostPerByte := new(big.Int).Set(l1BaseFee)
+ calldataCostPerByte = calldataCostPerByte.Mul(calldataCostPerByte, sixteen)
+ calldataCostPerByte = calldataCostPerByte.Mul(calldataCostPerByte, l1BaseFeeScalar)
+
+ blobCostPerByte := new(big.Int).Set(l1BlobBaseFee)
+ blobCostPerByte = blobCostPerByte.Mul(blobCostPerByte, l1BlobBaseFeeScalar)
+
+ fee = new(big.Int).Add(calldataCostPerByte, blobCostPerByte)
+ fee = fee.Mul(fee, calldataGasUsed)
+ fee = fee.Div(fee, ecotoneDivisor)
+
+ return fee, calldataGasUsed
+ }
+}
+
+type gasParams struct {
+ l1BaseFee *big.Int
+ l1BlobBaseFee *big.Int
+ costFunc l1CostFunc
+ feeScalar *big.Float // pre-ecotone
+ l1BaseFeeScalar *uint32 // post-ecotone
+ l1BlobBaseFeeScalar *uint32 // post-ecotone
+}
+
+// intToScaledFloat returns scalar/10e6 as a float
+func intToScaledFloat(scalar *big.Int) *big.Float {
+ fscalar := new(big.Float).SetInt(scalar)
+ fdivisor := new(big.Float).SetUint64(1_000_000) // 10**6, i.e. 6 decimals
+ return new(big.Float).Quo(fscalar, fdivisor)
+}
+
+// extractL1GasParams extracts the gas parameters necessary to compute gas costs from L1 block info
+func extractL1GasParams(config *params.ChainConfig, time uint64, data []byte) (gasParams, error) {
+ // edge case: for the very first Ecotone block we still need to use the Bedrock
+ // function. We detect this edge case by seeing if the function selector is the old one
+ // If so, fall through to the pre-ecotone format
+ // Both Ecotone and Fjord use the same function selector
+ if config.IsEcotone(time) && len(data) >= 4 && !bytes.Equal(data[0:4], BedrockL1AttributesSelector) {
+ p, err := extractL1GasParamsPostEcotone(data)
+ if err != nil {
+ return gasParams{}, err
+ }
+
+ if config.IsFjord(time) {
+ p.costFunc = NewL1CostFuncFjord(
+ p.l1BaseFee,
+ p.l1BlobBaseFee,
+ big.NewInt(int64(*p.l1BaseFeeScalar)),
+ big.NewInt(int64(*p.l1BlobBaseFeeScalar)),
+ )
+ } else {
+ p.costFunc = newL1CostFuncEcotone(
+ p.l1BaseFee,
+ p.l1BlobBaseFee,
+ big.NewInt(int64(*p.l1BaseFeeScalar)),
+ big.NewInt(int64(*p.l1BlobBaseFeeScalar)),
+ )
+ }
+
+ return p, nil
+ }
+ return extractL1GasParamsPreEcotone(config, time, data)
+}
+
+func extractL1GasParamsPreEcotone(config *params.ChainConfig, time uint64, data []byte) (gasParams, error) {
+ // data consists of func selector followed by 7 ABI-encoded parameters (32 bytes each)
+ if len(data) < 4+32*8 {
+ return gasParams{}, fmt.Errorf("expected at least %d L1 info bytes, got %d", 4+32*8, len(data))
+ }
+ data = data[4:] // trim function selector
+ l1BaseFee := new(big.Int).SetBytes(data[32*2 : 32*3]) // arg index 2
+ overhead := new(big.Int).SetBytes(data[32*6 : 32*7]) // arg index 6
+ scalar := new(big.Int).SetBytes(data[32*7 : 32*8]) // arg index 7
+ feeScalar := intToScaledFloat(scalar) // legacy: format fee scalar as big Float
+ costFunc := newL1CostFuncBedrockHelper(l1BaseFee, overhead, scalar, config.IsRegolith(time))
+ return gasParams{
+ l1BaseFee: l1BaseFee,
+ costFunc: costFunc,
+ feeScalar: feeScalar,
+ }, nil
+}
+
+// extractL1GasParamsPostEcotone extracts the gas parameters necessary to compute gas from L1 attribute
+// info calldata after the Ecotone upgrade, but not for the very first Ecotone block.
+func extractL1GasParamsPostEcotone(data []byte) (gasParams, error) {
+ if len(data) != 164 {
+ return gasParams{}, fmt.Errorf("expected 164 L1 info bytes, got %d", len(data))
+ }
+ // data layout assumed for Ecotone:
+ // offset type varname
+ // 0 <selector>
+ // 4 uint32 _basefeeScalar
+ // 8 uint32 _blobBaseFeeScalar
+ // 12 uint64 _sequenceNumber,
+ // 20 uint64 _timestamp,
+ // 28 uint64 _l1BlockNumber
+ // 36 uint256 _basefee,
+ // 68 uint256 _blobBaseFee,
+ // 100 bytes32 _hash,
+ // 132 bytes32 _batcherHash,
+ l1BaseFee := new(big.Int).SetBytes(data[36:68])
+ l1BlobBaseFee := new(big.Int).SetBytes(data[68:100])
+ l1BaseFeeScalar := binary.BigEndian.Uint32(data[4:8])
+ l1BlobBaseFeeScalar := binary.BigEndian.Uint32(data[8:12])
+ return gasParams{
+ l1BaseFee: l1BaseFee,
+ l1BlobBaseFee: l1BlobBaseFee,
+ l1BaseFeeScalar: &l1BaseFeeScalar,
+ l1BlobBaseFeeScalar: &l1BlobBaseFeeScalar,
+ }, nil
+}
+
+// L1Cost computes the the data availability fee for transactions in blocks prior to the Ecotone
+// upgrade. It is used by e2e tests so must remain exported.
+func L1Cost(rollupDataGas uint64, l1BaseFee, overhead, scalar *big.Int) *big.Int {
+ l1GasUsed := new(big.Int).SetUint64(rollupDataGas)
+ l1GasUsed.Add(l1GasUsed, overhead)
+ return l1CostHelper(l1GasUsed, l1BaseFee, scalar)
+}
+
+func l1CostHelper(gasWithOverhead, l1BaseFee, scalar *big.Int) *big.Int {
+ fee := new(big.Int).Set(gasWithOverhead)
+ fee.Mul(fee, l1BaseFee).Mul(fee, scalar).Div(fee, oneMillion)
+ return fee
+}
+
+// NewL1CostFuncFjord returns an l1 cost function suitable for the Fjord upgrade
+func NewL1CostFuncFjord(l1BaseFee, l1BlobBaseFee, baseFeeScalar, blobFeeScalar *big.Int) l1CostFunc {
+ return func(costData RollupCostData) (fee, calldataGasUsed *big.Int) {
+ // Fjord L1 cost function:
+ //l1FeeScaled = baseFeeScalar*l1BaseFee*16 + blobFeeScalar*l1BlobBaseFee
+ //estimatedSize = max(minTransactionSize, intercept + fastlzCoef*fastlzSize)
+ //l1Cost = estimatedSize * l1FeeScaled / 1e12
+
+ scaledL1BaseFee := new(big.Int).Mul(baseFeeScalar, l1BaseFee)
+ calldataCostPerByte := new(big.Int).Mul(scaledL1BaseFee, sixteen)
+ blobCostPerByte := new(big.Int).Mul(blobFeeScalar, l1BlobBaseFee)
+ l1FeeScaled := new(big.Int).Add(calldataCostPerByte, blobCostPerByte)
+
+ fastLzSize := new(big.Int).SetUint64(costData.FastLzSize)
+ estimatedSize := new(big.Int).Add(L1CostIntercept, new(big.Int).Mul(L1CostFastlzCoef, fastLzSize))
+
+ if estimatedSize.Cmp(MinTransactionSizeScaled) < 0 {
+ estimatedSize.Set(MinTransactionSizeScaled)
+ }
+
+ l1CostScaled := new(big.Int).Mul(estimatedSize, l1FeeScaled)
+ l1Cost := new(big.Int).Div(l1CostScaled, fjordDivisor)
+
+ calldataGasUsed = new(big.Int).Mul(estimatedSize, new(big.Int).SetUint64(params.TxDataNonZeroGasEIP2028))
+ calldataGasUsed.Div(calldataGasUsed, big.NewInt(1e6))
+
+ return l1Cost, calldataGasUsed
+ }
+}
+
+func extractEcotoneFeeParams(l1FeeParams []byte) (l1BaseFeeScalar, l1BlobBaseFeeScalar *big.Int) {
+ offset := scalarSectionStart
+ l1BaseFeeScalar = new(big.Int).SetBytes(l1FeeParams[offset : offset+4])
+ l1BlobBaseFeeScalar = new(big.Int).SetBytes(l1FeeParams[offset+4 : offset+8])
+ return
+}
+
+func bedrockCalldataGasUsed(costData RollupCostData) (calldataGasUsed *big.Int) {
+ calldataGas := (costData.Zeroes * params.TxDataZeroGas) + (costData.Ones * params.TxDataNonZeroGasEIP2028)
+ return new(big.Int).SetUint64(calldataGas)
+}
+
+// FlzCompressLen returns the length of the data after compression through FastLZ, based on
+// https://github.com/Vectorized/solady/blob/5315d937d79b335c668896d7533ac603adac5315/js/solady.js
+func FlzCompressLen(ib []byte) uint32 {
+ n := uint32(0)
+ ht := make([]uint32, 8192)
+ u24 := func(i uint32) uint32 {
+ return uint32(ib[i]) | (uint32(ib[i+1]) << 8) | (uint32(ib[i+2]) << 16)
+ }
+ cmp := func(p uint32, q uint32, e uint32) uint32 {
+ l := uint32(0)
+ for e -= q; l < e; l++ {
+ if ib[p+l] != ib[q+l] {
+ e = 0
+ }
+ }
+ return l
+ }
+ literals := func(r uint32) {
+ n += 0x21 * (r / 0x20)
+ r %= 0x20
+ if r != 0 {
+ n += r + 1
+ }
+ }
+ match := func(l uint32) {
+ l--
+ n += 3 * (l / 262)
+ if l%262 >= 6 {
+ n += 3
+ } else {
+ n += 2
+ }
+ }
+ hash := func(v uint32) uint32 {
+ return ((2654435769 * v) >> 19) & 0x1fff
+ }
+ setNextHash := func(ip uint32) uint32 {
+ ht[hash(u24(ip))] = ip
+ return ip + 1
+ }
+ a := uint32(0)
+ ipLimit := uint32(len(ib)) - 13
+ if len(ib) < 13 {
+ ipLimit = 0
+ }
+ for ip := a + 2; ip < ipLimit; {
+ r := uint32(0)
+ d := uint32(0)
+ for {
+ s := u24(ip)
+ h := hash(s)
+ r = ht[h]
+ ht[h] = ip
+ d = ip - r
+ if ip >= ipLimit {
+ break
+ }
+ ip++
+ if d <= 0x1fff && s == u24(r) {
+ break
+ }
+ }
+ if ip >= ipLimit {
+ break
+ }
+ ip--
+ if ip > a {
+ literals(ip - a)
+ }
+ l := cmp(r+3, ip+3, ipLimit+9)
+ match(l)
+ ip = setNextHash(setNextHash(ip + l))
+ a = ip
+ }
+ literals(uint32(len(ib)) - a)
+ return n
+}
diff --git go-ethereum/core/vm/evm.go op-geth/core/vm/evm.go
index 16cc8549080ac0bb0210975ee96693e085ca384a..a816fd978da0766caf424468b674710c47664942 100644
--- go-ethereum/core/vm/evm.go
+++ op-geth/core/vm/evm.go
@@ -20,11 +20,12 @@ import (
"math/big"
"sync/atomic"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
)
type (
@@ -40,6 +41,8 @@
func (evm *EVM) precompile(addr common.Address) (PrecompiledContract, bool) {
var precompiles map[common.Address]PrecompiledContract
switch {
+ case evm.chainRules.IsOptimismFjord:
+ precompiles = PrecompiledContractsFjord
case evm.chainRules.IsCancun:
precompiles = PrecompiledContractsCancun
case evm.chainRules.IsBerlin:
@@ -52,6 +55,13 @@ default:
precompiles = PrecompiledContractsHomestead
}
p, ok := precompiles[addr]
+ // Restrict overrides to known precompiles
+ if ok && evm.chainConfig.IsOptimism() && evm.Config.OptimismPrecompileOverrides != nil {
+ override, ok := evm.Config.OptimismPrecompileOverrides(evm.chainRules, p, addr)
+ if ok {
+ return override, ok
+ }
+ }
return p, ok
}
@@ -65,6 +75,8 @@ // Transfer transfers ether from one account to the other
Transfer TransferFunc
// GetHash returns the hash corresponding to n
GetHash GetHashFunc
+ // L1CostFunc returns the L1 cost of the rollup message, the function may be nil, or return nil
+ L1CostFunc types.L1CostFunc
// Block information
Coinbase common.Address // Provides information for COINBASE
Transaction processing
+135
-16
Deposit transactions have special processing rules: gas is pre-paid on L1, and deposits with EVM-failure are included with rolled back changes (except mint). For regular transactions, at the end of the transition, the 1559 burn and L1 cost are routed to vaults.
diff --git go-ethereum/core/state_transition.go op-geth/core/state_transition.go
index 9c4f76d1c58538b9fe8ead870c989f27bfbd70b6..9de1b63e211d104677151adb5d5f93da44dcd6c0 100644
--- go-ethereum/core/state_transition.go
+++ op-geth/core/state_transition.go
@@ -21,13 +21,13 @@ "fmt"
"math"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- cmath "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ cmath "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/params"
)
// ExecutionResult includes all output after executing given evm
@@ -145,20 +145,30 @@ // When SkipAccountChecks is true, the message nonce is not checked against the
// account nonce in state. It also disables checking that the sender is an EOA.
// This field will be set to true for operations like RPC eth_call.
SkipAccountChecks bool
+
+ IsSystemTx bool // IsSystemTx indicates the message, if also a deposit, does not emit gas usage.
+ IsDepositTx bool // IsDepositTx indicates the message is force-included and can persist a mint.
+ Mint *big.Int // Mint is the amount to mint before EVM processing, or nil if there is no minting.
+ RollupCostData types.RollupCostData // RollupCostData caches data to compute the fee we charge for data availability
}
// TransactionToMessage converts a transaction into a Message.
func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int) (*Message, error) {
msg := &Message{
- Nonce: tx.Nonce(),
- GasLimit: tx.Gas(),
- GasPrice: new(big.Int).Set(tx.GasPrice()),
- GasFeeCap: new(big.Int).Set(tx.GasFeeCap()),
- GasTipCap: new(big.Int).Set(tx.GasTipCap()),
- To: tx.To(),
- Value: tx.Value(),
- Data: tx.Data(),
- AccessList: tx.AccessList(),
+ Nonce: tx.Nonce(),
+ GasLimit: tx.Gas(),
+ GasPrice: new(big.Int).Set(tx.GasPrice()),
+ GasFeeCap: new(big.Int).Set(tx.GasFeeCap()),
+ GasTipCap: new(big.Int).Set(tx.GasTipCap()),
+ To: tx.To(),
+ Value: tx.Value(),
+ Data: tx.Data(),
+ AccessList: tx.AccessList(),
+ IsSystemTx: tx.IsSystemTx(),
+ IsDepositTx: tx.IsDepositTx(),
+ Mint: tx.Mint(),
+ RollupCostData: tx.RollupCostData(),
+
SkipAccountChecks: false,
BlobHashes: tx.BlobHashes(),
BlobGasFeeCap: tx.BlobGasFeeCap(),
@@ -235,11 +245,21 @@
func (st *StateTransition) buyGas() error {
mgval := new(big.Int).SetUint64(st.msg.GasLimit)
mgval = mgval.Mul(mgval, st.msg.GasPrice)
+ var l1Cost *big.Int
+ if st.evm.Context.L1CostFunc != nil && !st.msg.SkipAccountChecks {
+ l1Cost = st.evm.Context.L1CostFunc(st.msg.RollupCostData, st.evm.Context.Time)
+ if l1Cost != nil {
+ mgval = mgval.Add(mgval, l1Cost)
+ }
+ }
balanceCheck := new(big.Int).Set(mgval)
if st.msg.GasFeeCap != nil {
balanceCheck.SetUint64(st.msg.GasLimit)
balanceCheck = balanceCheck.Mul(balanceCheck, st.msg.GasFeeCap)
balanceCheck.Add(balanceCheck, st.msg.Value)
+ if l1Cost != nil {
+ balanceCheck.Add(balanceCheck, l1Cost)
+ }
}
if st.evm.ChainConfig().IsCancun(st.evm.Context.BlockNumber, st.evm.Context.Time) {
if blobGas := st.blobGasUsed(); blobGas > 0 {
@@ -272,6 +292,21 @@ return nil
}
func (st *StateTransition) preCheck() error {
+ if st.msg.IsDepositTx {
+ // No fee fields to check, no nonce to check, and no need to check if EOA (L1 already verified it for us)
+ // Gas is free, but no refunds!
+ st.initialGas = st.msg.GasLimit
+ st.gasRemaining += st.msg.GasLimit // Add gas here in order to be able to execute calls.
+ // Don't touch the gas pool for system transactions
+ if st.msg.IsSystemTx {
+ if st.evm.ChainConfig().IsOptimismRegolith(st.evm.Context.Time) {
+ return fmt.Errorf("%w: address %v", ErrSystemTxNotSupported,
+ st.msg.From.Hex())
+ }
+ return nil
+ }
+ return st.gp.SubGas(st.msg.GasLimit) // gas used by deposits may not be used by other txs
+ }
// Only check transactions that are not fake
msg := st.msg
if !msg.SkipAccountChecks {
@@ -365,6 +400,41 @@ //
// However if any consensus issue encountered, return the error directly with
// nil evm execution result.
func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
+ if mint := st.msg.Mint; mint != nil {
+ mintU256, overflow := uint256.FromBig(mint)
+ if overflow {
+ return nil, fmt.Errorf("mint value exceeds uint256: %d", mintU256)
+ }
+ st.state.AddBalance(st.msg.From, mintU256)
+ }
+ snap := st.state.Snapshot()
+
+ result, err := st.innerTransitionDb()
+ // Failed deposits must still be included. Unless we cannot produce the block at all due to the gas limit.
+ // On deposit failure, we rewind any state changes from after the minting, and increment the nonce.
+ if err != nil && err != ErrGasLimitReached && st.msg.IsDepositTx {
+ st.state.RevertToSnapshot(snap)
+ // Even though we revert the state changes, always increment the nonce for the next deposit transaction
+ st.state.SetNonce(st.msg.From, st.state.GetNonce(st.msg.From)+1)
+ // Record deposits as using all their gas (matches the gas pool)
+ // System Transactions are special & are not recorded as using any gas (anywhere)
+ // Regolith changes this behaviour so the actual gas used is reported.
+ // In this case the tx is invalid so is recorded as using all gas.
+ gasUsed := st.msg.GasLimit
+ if st.msg.IsSystemTx && !st.evm.ChainConfig().IsRegolith(st.evm.Context.Time) {
+ gasUsed = 0
+ }
+ result = &ExecutionResult{
+ UsedGas: gasUsed,
+ Err: fmt.Errorf("failed deposit: %w", err),
+ ReturnData: nil,
+ }
+ err = nil
+ }
+ return result, err
+}
+
+func (st *StateTransition) innerTransitionDb() (*ExecutionResult, error) {
// First check this message satisfies all consensus rules before
// applying the message. The rules include these clauses
//
@@ -383,7 +453,11 @@
if tracer := st.evm.Config.Tracer; tracer != nil {
tracer.CaptureTxStart(st.initialGas)
defer func() {
- tracer.CaptureTxEnd(st.gasRemaining)
+ if st.msg.IsDepositTx {
+ tracer.CaptureTxEnd(0)
+ } else {
+ tracer.CaptureTxEnd(st.gasRemaining)
+ }
}()
}
@@ -435,6 +509,24 @@ st.state.SetNonce(msg.From, st.state.GetNonce(sender.Address())+1)
ret, st.gasRemaining, vmerr = st.evm.Call(sender, st.to(), msg.Data, st.gasRemaining, value)
}
+ // if deposit: skip refunds, skip tipping coinbase
+ // Regolith changes this behaviour to report the actual gasUsed instead of always reporting all gas used.
+ if st.msg.IsDepositTx && !rules.IsOptimismRegolith {
+ // Record deposits as using all their gas (matches the gas pool)
+ // System Transactions are special & are not recorded as using any gas (anywhere)
+ gasUsed := st.msg.GasLimit
+ if st.msg.IsSystemTx {
+ gasUsed = 0
+ }
+ return &ExecutionResult{
+ UsedGas: gasUsed,
+ Err: vmerr,
+ ReturnData: ret,
+ }, nil
+ }
+ // Note for deposit tx there is no ETH refunded for unused gas, but that's taken care of by the fact that gasPrice
+ // is always 0 for deposit tx. So calling refundGas will ensure the gasUsed accounting is correct without actually
+ // changing the sender's balance
var gasRefund uint64
if !rules.IsLondon {
// Before EIP-3529: refunds were capped to gasUsed / 2
@@ -442,6 +534,15 @@ gasRefund = st.refundGas(params.RefundQuotient)
} else {
// After EIP-3529: refunds are capped to gasUsed / 5
gasRefund = st.refundGas(params.RefundQuotientEIP3529)
+ }
+ if st.msg.IsDepositTx && rules.IsOptimismRegolith {
+ // Skip coinbase payments for deposit tx in Regolith
+ return &ExecutionResult{
+ UsedGas: st.gasUsed(),
+ RefundedGas: gasRefund,
+ Err: vmerr,
+ ReturnData: ret,
+ }, nil
}
effectiveTip := msg.GasPrice
if rules.IsLondon {
@@ -457,6 +558,24 @@ } else {
fee := new(uint256.Int).SetUint64(st.gasUsed())
fee.Mul(fee, effectiveTipU256)
st.state.AddBalance(st.evm.Context.Coinbase, fee)
+ }
+
+ // Check that we are post bedrock to enable op-geth to be able to create pseudo pre-bedrock blocks (these are pre-bedrock, but don't follow l2 geth rules)
+ // Note optimismConfig will not be nil if rules.IsOptimismBedrock is true
+ if optimismConfig := st.evm.ChainConfig().Optimism; optimismConfig != nil && rules.IsOptimismBedrock && !st.msg.IsDepositTx {
+ gasCost := new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.evm.Context.BaseFee)
+ amtU256, overflow := uint256.FromBig(gasCost)
+ if overflow {
+ return nil, fmt.Errorf("optimism gas cost overflows U256: %d", gasCost)
+ }
+ st.state.AddBalance(params.OptimismBaseFeeRecipient, amtU256)
+ if l1Cost := st.evm.Context.L1CostFunc(st.msg.RollupCostData, st.evm.Context.Time); l1Cost != nil {
+ amtU256, overflow = uint256.FromBig(l1Cost)
+ if overflow {
+ return nil, fmt.Errorf("optimism l1 cost overflows U256: %d", l1Cost)
+ }
+ st.state.AddBalance(params.OptimismL1FeeRecipient, amtU256)
+ }
}
return &ExecutionResult{
Core Error definitions
+4
-1
diff --git go-ethereum/core/error.go op-geth/core/error.go
index 72cacf8c78d2fdb4ee98563edbfda8c094057521..f7dd975fdc7e34618ecefa8482eeb0de7b3c2875 100644
--- go-ethereum/core/error.go
+++ op-geth/core/error.go
@@ -19,7 +19,7 @@
import (
"errors"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/core/types"
)
var (
@@ -110,4 +110,7 @@ ErrMissingBlobHashes = errors.New("blob transaction missing blob hashes")
// ErrBlobTxCreate is returned if a blob transaction has no explicit to field.
ErrBlobTxCreate = errors.New("blob transaction of type create")
+
+ // ErrSystemTxNotSupported is returned for any deposit tx with IsSystemTx=true after the Regolith fork
+ ErrSystemTxNotSupported = errors.New("system tx not supported")
)
Gaslimit
+14
-11
The gaslimit is free to be set by the Engine API caller, instead of enforcing adjustments of the
gaslimit in increments of 1⁄1024 of the previous gaslimit.
The gaslimit is changed (and limited) through the SystemConfig contract.
diff --git go-ethereum/consensus/misc/eip1559/eip1559.go op-geth/consensus/misc/eip1559/eip1559.go
index 84b82c4c492ec1351da2129b51b99fc50d3c6b28..065361d4542233542e4f51fb85cf339e74559088 100644
--- go-ethereum/consensus/misc/eip1559/eip1559.go
+++ op-geth/consensus/misc/eip1559/eip1559.go
@@ -21,11 +21,11 @@ "errors"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus/misc"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus/misc"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
// VerifyEIP1559Header verifies some header attributes which were changed in EIP-1559,
@@ -37,15 +37,17 @@ parentGasLimit := parent.GasLimit
if !config.IsLondon(parent.Number) {
parentGasLimit = parent.GasLimit * config.ElasticityMultiplier()
}
- if err := misc.VerifyGaslimit(parentGasLimit, header.GasLimit); err != nil {
- return err
+ if config.Optimism == nil { // gasLimit can adjust instantly in optimism
+ if err := misc.VerifyGaslimit(parentGasLimit, header.GasLimit); err != nil {
+ return err
+ }
}
// Verify the header is not malformed
if header.BaseFee == nil {
return errors.New("header is missing baseFee")
}
// Verify the baseFee is correct based on the parent header.
- expectedBaseFee := CalcBaseFee(config, parent)
+ expectedBaseFee := CalcBaseFee(config, parent, header.Time)
if header.BaseFee.Cmp(expectedBaseFee) != 0 {
return fmt.Errorf("invalid baseFee: have %s, want %s, parentBaseFee %s, parentGasUsed %d",
header.BaseFee, expectedBaseFee, parent.BaseFee, parent.GasUsed)
@@ -54,7 +56,8 @@ return nil
}
// CalcBaseFee calculates the basefee of the header.
-func CalcBaseFee(config *params.ChainConfig, parent *types.Header) *big.Int {
+// The time belongs to the new block to check if Canyon is activted or not
+func CalcBaseFee(config *params.ChainConfig, parent *types.Header, time uint64) *big.Int {
// If the current block is the first EIP-1559 block, return the InitialBaseFee.
if !config.IsLondon(parent.Number) {
return new(big.Int).SetUint64(params.InitialBaseFee)
@@ -77,7 +80,7 @@ // max(1, parentBaseFee * gasUsedDelta / parentGasTarget / baseFeeChangeDenominator)
num.SetUint64(parent.GasUsed - parentGasTarget)
num.Mul(num, parent.BaseFee)
num.Div(num, denom.SetUint64(parentGasTarget))
- num.Div(num, denom.SetUint64(config.BaseFeeChangeDenominator()))
+ num.Div(num, denom.SetUint64(config.BaseFeeChangeDenominator(time)))
baseFeeDelta := math.BigMax(num, common.Big1)
return num.Add(parent.BaseFee, baseFeeDelta)
@@ -87,7 +90,7 @@ // max(0, parentBaseFee * gasUsedDelta / parentGasTarget / baseFeeChangeDenominator)
num.SetUint64(parentGasTarget - parent.GasUsed)
num.Mul(num, parent.BaseFee)
num.Div(num, denom.SetUint64(parentGasTarget))
- num.Div(num, denom.SetUint64(config.BaseFeeChangeDenominator()))
+ num.Div(num, denom.SetUint64(config.BaseFeeChangeDenominator(time)))
baseFee := num.Sub(parent.BaseFee, num)
return math.BigMax(baseFee, common.Big0)
Consensus tweaks
+37
-9
The Engine API is activated at the Merge transition, with a Total Terminal Difficulty (TTD). The rollup starts post-merge, and thus sets the TTD to 0. The TTD is always “reached” starting at the bedrock block.
diff --git go-ethereum/consensus/beacon/consensus.go op-geth/consensus/beacon/consensus.go
index a350e383a293223be8f50e236d808c6e5fbe0345..42d02981e60c9d3810a38116d5b17d2a2c26b579 100644
--- go-ethereum/consensus/beacon/consensus.go
+++ op-geth/consensus/beacon/consensus.go
@@ -21,16 +21,16 @@ "errors"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/trie"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
+ "github.com/tenderly/op-geth/trie"
)
// Proof-of-stake protocol constants.
@@ -59,6 +59,7 @@ // The beacon here is a half-functional consensus engine with partial functions which
// is only used for necessary consensus checks. The legacy consensus engine can be any
// engine implements the consensus interface (except the beacon itself).
type Beacon struct {
+ // For migrated OP chains (OP mainnet, OP Goerli), ethone is a dummy legacy pre-Bedrock consensus
ethone consensus.Engine // Original consensus engine used in eth1, e.g. ethash or clique
}
@@ -106,12 +107,27 @@ }
return errs
}
+// OP-Stack Bedrock variant of splitHeaders: the total-terminal difficulty is terminated at bedrock transition, but also reset to 0.
+// So just use the bedrock fork check to split the headers, to simplify the splitting.
+// The returned slices are slices over the input. The input must be sorted.
+func (beacon *Beacon) splitBedrockHeaders(chain consensus.ChainHeaderReader, headers []*types.Header) ([]*types.Header, []*types.Header, error) {
+ for i, h := range headers {
+ if chain.Config().IsBedrock(h.Number) {
+ return headers[:i], headers[i:], nil
+ }
+ }
+ return headers, nil, nil
+}
+
// splitHeaders splits the provided header batch into two parts according to
// the configured ttd. It requires the parent of header batch along with its
// td are stored correctly in chain. If ttd is not configured yet, all headers
// will be treated legacy PoW headers.
// Note, this function will not verify the header validity but just split them.
func (beacon *Beacon) splitHeaders(chain consensus.ChainHeaderReader, headers []*types.Header) ([]*types.Header, []*types.Header, error) {
+ if chain.Config().Optimism != nil {
+ return beacon.splitBedrockHeaders(chain, headers)
+ }
// TTD is not defined yet, all headers should be in legacy format.
ttd := chain.Config().TerminalTotalDifficulty
if ttd == nil {
@@ -447,6 +463,10 @@ func (beacon *Beacon) InnerEngine() consensus.Engine {
return beacon.ethone
}
+func (beacon *Beacon) SwapInner(inner consensus.Engine) {
+ beacon.ethone = inner
+}
+
// SetThreads updates the mining threads. Delegate the call
// to the eth1 engine if it's threaded.
func (beacon *Beacon) SetThreads(threads int) {
@@ -462,8 +482,16 @@ // IsTTDReached checks if the TotalTerminalDifficulty has been surpassed on the `parentHash` block.
// It depends on the parentHash already being stored in the database.
// If the parentHash is not stored in the database a UnknownAncestor error is returned.
func IsTTDReached(chain consensus.ChainHeaderReader, parentHash common.Hash, parentNumber uint64) (bool, error) {
+ if cfg := chain.Config(); cfg.Optimism != nil {
+ // If OP-Stack then bedrock activation number determines when TTD (eth Merge) has been reached.
+ // Note: some tests/utils will set parentNumber == max_uint64 as "parent" of the genesis block, this is fine.
+ return cfg.IsBedrock(new(big.Int).SetUint64(parentNumber + 1)), nil
+ }
if chain.Config().TerminalTotalDifficulty == nil {
return false, nil
+ }
+ if common.Big0.Cmp(chain.Config().TerminalTotalDifficulty) == 0 { // in case TTD is reached at genesis.
+ return true, nil
}
td := chain.GetTd(parentHash, parentNumber)
if td == nil {
Legacy OP-mainnet / OP-goerli header-verification support
+91
-0
Pre-Bedrock OP-mainnet and OP-Goerli had differently formatted block-headers, loosely compatible with the geth types (since it was based on Clique). However, due to differences like the extra-data length (97+ bytes), these legacy block-headers need special verification. The pre-merge “consensus” fallback is set to this custom but basic verifier, to accept these headers when syncing a pre-bedrock part of the chain, independent of any clique code or configuration (which may be removed from geth at a later point). All the custom verifier has to do is accept the headers, as the headers are already verified by block-hash through the reverse-header-sync.
diff --git go-ethereum/consensus/beacon/oplegacy.go op-geth/consensus/beacon/oplegacy.go
new file mode 100644
index 0000000000000000000000000000000000000000..b96bb887b735cd9c4ddb69b381150baa018f58ae
--- /dev/null
+++ op-geth/consensus/beacon/oplegacy.go
@@ -0,0 +1,91 @@
+package beacon
+
+import (
+ "fmt"
+ "math/big"
+
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rpc"
+)
+
+type OpLegacy struct{}
+
+func (o *OpLegacy) Author(header *types.Header) (common.Address, error) {
+ return header.Coinbase, nil
+}
+
+func (o *OpLegacy) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header) error {
+ // Short circuit if the header is known, or its parent not
+ number := header.Number.Uint64()
+ if chain.GetHeader(header.Hash(), number) != nil {
+ return nil
+ }
+ parent := chain.GetHeader(header.ParentHash, number-1)
+ if parent == nil {
+ return consensus.ErrUnknownAncestor
+ }
+ // legacy chain is verified by block-hash reverse sync otherwise
+ return nil
+}
+
+func (o *OpLegacy) VerifyHeaders(chain consensus.ChainHeaderReader, headers []*types.Header) (chan<- struct{}, <-chan error) {
+ abort := make(chan struct{})
+ results := make(chan error, len(headers))
+
+ for i := range headers {
+ // legacy chain is verified by block-hash reverse sync
+ var parent *types.Header
+ if i == 0 {
+ parent = chain.GetHeader(headers[0].ParentHash, headers[0].Number.Uint64()-1)
+ } else if headers[i-1].Hash() == headers[i].ParentHash {
+ parent = headers[i-1]
+ }
+ var err error
+ if parent == nil {
+ err = consensus.ErrUnknownAncestor
+ }
+ results <- err
+ }
+ return abort, results
+}
+
+func (o *OpLegacy) VerifyUncles(chain consensus.ChainReader, block *types.Block) error {
+ return nil
+}
+
+func (o *OpLegacy) Prepare(chain consensus.ChainHeaderReader, header *types.Header) error {
+ return fmt.Errorf("cannot prepare for legacy block header: %s (num %d)", header.Hash(), header.Number)
+}
+
+func (o *OpLegacy) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, withdrawals []*types.Withdrawal) {
+ panic(fmt.Errorf("cannot finalize legacy block header: %s (num %d)", header.Hash(), header.Number))
+}
+
+func (o *OpLegacy) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt, withdrawals []*types.Withdrawal) (*types.Block, error) {
+ return nil, fmt.Errorf("cannot finalize and assemble for legacy block header: %s (num %d)", header.Hash(), header.Number)
+}
+
+func (o *OpLegacy) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
+ return fmt.Errorf("cannot seal legacy block header: %s (num %d)", block.Hash(), block.Number())
+}
+
+func (o *OpLegacy) SealHash(header *types.Header) common.Hash {
+ panic(fmt.Errorf("cannot compute pow/poa seal-hash for legacy block header: %s (num %d)", header.Hash(), header.Number))
+}
+
+func (o *OpLegacy) CalcDifficulty(chain consensus.ChainHeaderReader, time uint64, parent *types.Header) *big.Int {
+ return big.NewInt(0)
+}
+
+func (o *OpLegacy) APIs(chain consensus.ChainHeaderReader) []rpc.API {
+ return nil
+}
+
+func (o *OpLegacy) Close() error {
+ return nil
+}
+
+var _ consensus.Engine = (*OpLegacy)(nil)
Engine API modifications
+86
-23
The Engine API is extended to insert transactions into the block and optionally exclude the tx-pool, to reproduce the exact block of the sequencer from just the inputs, as derived from L1 by the rollup-node. See L2 execution engine specs.
diff --git go-ethereum/beacon/engine/gen_blockparams.go op-geth/beacon/engine/gen_blockparams.go
index b1f01b50ff8e3b1adf0454ff989356a6f612a337..712c710fb9da075303f20541f0ceaff6ec059709 100644
--- go-ethereum/beacon/engine/gen_blockparams.go
+++ op-geth/beacon/engine/gen_blockparams.go
@@ -6,9 +6,9 @@ import (
"encoding/json"
"errors"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
)
var _ = (*payloadAttributesMarshaling)(nil)
@@ -21,6 +21,9 @@ Random common.Hash `json:"prevRandao" gencodec:"required"`
SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"`
Withdrawals []*types.Withdrawal `json:"withdrawals"`
BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"`
+ Transactions []hexutil.Bytes `json:"transactions,omitempty" gencodec:"optional"`
+ NoTxPool bool `json:"noTxPool,omitempty" gencodec:"optional"`
+ GasLimit *hexutil.Uint64 `json:"gasLimit,omitempty" gencodec:"optional"`
}
var enc PayloadAttributes
enc.Timestamp = hexutil.Uint64(p.Timestamp)
@@ -28,6 +31,14 @@ enc.Random = p.Random
enc.SuggestedFeeRecipient = p.SuggestedFeeRecipient
enc.Withdrawals = p.Withdrawals
enc.BeaconRoot = p.BeaconRoot
+ if p.Transactions != nil {
+ enc.Transactions = make([]hexutil.Bytes, len(p.Transactions))
+ for k, v := range p.Transactions {
+ enc.Transactions[k] = v
+ }
+ }
+ enc.NoTxPool = p.NoTxPool
+ enc.GasLimit = (*hexutil.Uint64)(p.GasLimit)
return json.Marshal(&enc)
}
@@ -39,6 +50,9 @@ Random *common.Hash `json:"prevRandao" gencodec:"required"`
SuggestedFeeRecipient *common.Address `json:"suggestedFeeRecipient" gencodec:"required"`
Withdrawals []*types.Withdrawal `json:"withdrawals"`
BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"`
+ Transactions []hexutil.Bytes `json:"transactions,omitempty" gencodec:"optional"`
+ NoTxPool *bool `json:"noTxPool,omitempty" gencodec:"optional"`
+ GasLimit *hexutil.Uint64 `json:"gasLimit,omitempty" gencodec:"optional"`
}
var dec PayloadAttributes
if err := json.Unmarshal(input, &dec); err != nil {
@@ -61,6 +75,18 @@ p.Withdrawals = dec.Withdrawals
}
if dec.BeaconRoot != nil {
p.BeaconRoot = dec.BeaconRoot
+ }
+ if dec.Transactions != nil {
+ p.Transactions = make([][]byte, len(dec.Transactions))
+ for k, v := range dec.Transactions {
+ p.Transactions[k] = v
+ }
+ }
+ if dec.NoTxPool != nil {
+ p.NoTxPool = *dec.NoTxPool
+ }
+ if dec.GasLimit != nil {
+ p.GasLimit = (*uint64)(dec.GasLimit)
}
return nil
}
diff --git go-ethereum/beacon/engine/types.go op-geth/beacon/engine/types.go
index 60accc3c7917cd162b6212e8932259c640fa1c0b..63f47be9f6152c7df5b1fd43718b581d89d5e363 100644
--- go-ethereum/beacon/engine/types.go
+++ op-geth/beacon/engine/types.go
@@ -20,10 +20,10 @@ import (
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/trie"
)
// PayloadVersion denotes the version of PayloadAttributes used to request the
@@ -46,11 +46,22 @@ Random common.Hash `json:"prevRandao" gencodec:"required"`
SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"`
Withdrawals []*types.Withdrawal `json:"withdrawals"`
BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"`
+
+ // Transactions is a field for rollups: the transactions list is forced into the block
+ Transactions [][]byte `json:"transactions,omitempty" gencodec:"optional"`
+ // NoTxPool is a field for rollups: if true, the no transactions are taken out of the tx-pool,
+ // only transactions from the above Transactions list will be included.
+ NoTxPool bool `json:"noTxPool,omitempty" gencodec:"optional"`
+ // GasLimit is a field for rollups: if set, this sets the exact gas limit the block produced with.
+ GasLimit *uint64 `json:"gasLimit,omitempty" gencodec:"optional"`
}
// JSON type overrides for PayloadAttributes.
type payloadAttributesMarshaling struct {
Timestamp hexutil.Uint64
+
+ Transactions []hexutil.Bytes
+ GasLimit *hexutil.Uint64
}
//go:generate go run github.com/fjl/gencodec -type ExecutableData -field-override executableDataMarshaling -out gen_ed.go
@@ -97,6 +108,9 @@ ExecutionPayload *ExecutableData `json:"executionPayload" gencodec:"required"`
BlockValue *big.Int `json:"blockValue" gencodec:"required"`
BlobsBundle *BlobsBundleV1 `json:"blobsBundle"`
Override bool `json:"shouldOverrideBuilder"`
+
+ // OP-Stack: Ecotone specific fields
+ ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot,omitempty"`
}
type BlobsBundleV1 struct {
@@ -295,7 +309,13 @@ bundle.Commitments = append(bundle.Commitments, hexutil.Bytes(sidecar.Commitments[j][:]))
bundle.Proofs = append(bundle.Proofs, hexutil.Bytes(sidecar.Proofs[j][:]))
}
}
- return &ExecutionPayloadEnvelope{ExecutionPayload: data, BlockValue: fees, BlobsBundle: &bundle, Override: false}
+ return &ExecutionPayloadEnvelope{
+ ExecutionPayload: data,
+ BlockValue: fees,
+ BlobsBundle: &bundle,
+ Override: false,
+ ParentBeaconBlockRoot: block.BeaconRoot(),
+ }
}
// ExecutionPayloadBodyV1 is used in the response to GetPayloadBodiesByHashV1 and GetPayloadBodiesByRangeV1
diff --git go-ethereum/eth/catalyst/api.go op-geth/eth/catalyst/api.go
index 58566a47fc6c36d3eca9f2dcb1f52c5de8010fa5..a32ad0a75fff805a9e6c48deaf7e82a68c079c3f 100644
--- go-ethereum/eth/catalyst/api.go
+++ op-geth/eth/catalyst/api.go
@@ -23,20 +23,20 @@ "fmt"
"sync"
"time"
- "github.com/ethereum/go-ethereum/beacon/engine"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/internal/version"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/miner"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/params/forks"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/beacon/engine"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/internal/version"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/miner"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/params/forks"
+ "github.com/tenderly/op-geth/rpc"
)
// Register adds the engine API to the full node.
@@ -327,7 +327,7 @@ } else if api.eth.BlockChain().CurrentBlock().Hash() == update.HeadBlockHash {
// If the specified head matches with our local head, do nothing and keep
// generating the payload. It's a special corner case that a few slots are
// missing and we are requested to generate the payload in slot.
- } else {
+ } else if api.eth.BlockChain().Config().Optimism == nil { // minor Engine API divergence: allow proposers to reorg their own chain
// If the head block is already in our canonical chain, the beacon client is
// probably resyncing. Ignore the update.
log.Info("Ignoring beacon update to old head", "number", block.NumberU64(), "hash", update.HeadBlockHash, "age", common.PrettyAge(time.Unix(int64(block.Time()), 0)), "have", api.eth.BlockChain().CurrentBlock().Number)
@@ -371,6 +371,17 @@ // If payload generation was requested, create a new block to be potentially
// sealed by the beacon client. The payload will be requested later, and we
// will replace it arbitrarily many times in between.
if payloadAttributes != nil {
+ if api.eth.BlockChain().Config().Optimism != nil && payloadAttributes.GasLimit == nil {
+ return engine.STATUS_INVALID, engine.InvalidPayloadAttributes.With(errors.New("gasLimit parameter is required"))
+ }
+ transactions := make(types.Transactions, 0, len(payloadAttributes.Transactions))
+ for i, otx := range payloadAttributes.Transactions {
+ var tx types.Transaction
+ if err := tx.UnmarshalBinary(otx); err != nil {
+ return engine.STATUS_INVALID, fmt.Errorf("transaction %d is not valid: %v", i, err)
+ }
+ transactions = append(transactions, &tx)
+ }
args := &miner.BuildPayloadArgs{
Parent: update.HeadBlockHash,
Timestamp: payloadAttributes.Timestamp,
@@ -378,6 +389,9 @@ FeeRecipient: payloadAttributes.SuggestedFeeRecipient,
Random: payloadAttributes.Random,
Withdrawals: payloadAttributes.Withdrawals,
BeaconRoot: payloadAttributes.BeaconRoot,
+ NoTxPool: payloadAttributes.NoTxPool,
+ Transactions: transactions,
+ GasLimit: payloadAttributes.GasLimit,
Version: payloadVersion,
}
id := args.Id()
@@ -759,6 +773,9 @@ // user that something might be off with their consensus node.
//
// TODO(karalabe): Spin this goroutine down somehow
func (api *ConsensusAPI) heartbeat() {
+ if api.eth.BlockChain().Config().Optimism != nil { // don't start the api heartbeat, there is no transition
+ return
+ }
// Sleep a bit on startup since there's obviously no beacon client yet
// attached, so no need to print scary warnings to the user.
time.Sleep(beaconUpdateStartupTimeout)
Block-building modifications
+453
-142
The block-building code (in the “miner” package because of Proof-Of-Work legacy of ethereum) implements the changes to support the transaction-inclusion, tx-pool toggle and gaslimit parameters of the Engine API.
diff --git go-ethereum/miner/miner.go op-geth/miner/miner.go
index 58bb71b557b8d6dd7aabbb63751f6877877ae344..9f466a0b5387d41d66a53f72a93e720aa5f0438d 100644
--- go-ethereum/miner/miner.go
+++ op-geth/miner/miner.go
@@ -18,22 +18,24 @@ // Package miner implements Ethereum block creation and mining.
package miner
import (
+ "context"
"fmt"
"math/big"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
)
// Backend wraps all methods required for mining. Only full node is capable
@@ -43,6 +45,10 @@ BlockChain() *core.BlockChain
TxPool() *txpool.TxPool
}
+type BackendWithHistoricalState interface {
+ StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, tracers.StateReleaseFunc, error)
+}
+
// Config is the configuration parameters of mining.
type Config struct {
Etherbase common.Address `toml:",omitempty"` // Public address for block mining rewards
@@ -53,12 +59,15 @@ GasPrice *big.Int // Minimum gas price for mining a transaction
Recommit time.Duration // The time interval for miner to re-create mining work.
NewPayloadTimeout time.Duration // The maximum time allowance for creating a new payload
+
+ RollupComputePendingBlock bool // Compute the pending block from tx-pool, instead of copying the latest-block
+ EffectiveGasCeil uint64 // if non-zero, a gas ceiling to apply independent of the header's gaslimit value
}
// DefaultConfig contains default settings for miner.
var DefaultConfig = Config{
GasCeil: 30000000,
- GasPrice: big.NewInt(params.GWei),
+ GasPrice: big.NewInt(params.Wei),
// The default recommit time is chosen as two seconds since
// consensus-layer usually will wait a half slot of time(6s)
diff --git go-ethereum/miner/miner_test.go op-geth/miner/miner_test.go
index 5907fb44646637a957aca428ff2341d5a4e6f4c0..cd60c9992e299fa7544bcd3d65f0feef8f947634 100644
--- go-ethereum/miner/miner_test.go
+++ op-geth/miner/miner_test.go
@@ -23,21 +23,21 @@ "math/big"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/clique"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/txpool/legacypool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/clique"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/txpool/legacypool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/triedb"
)
type mockBackend struct {
diff --git go-ethereum/miner/ordering.go op-geth/miner/ordering.go
index bcf7af46e8912eda5d169580ee777e7e419b53df..40aa56d7e310f4d53b76e88bdd34fd9ca9579ba4 100644
--- go-ethereum/miner/ordering.go
+++ op-geth/miner/ordering.go
@@ -20,10 +20,10 @@ import (
"container/heap"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
)
// txWithMinerFee wraps a transaction with its gas price or effective miner gasTipCap
diff --git go-ethereum/miner/ordering_test.go op-geth/miner/ordering_test.go
index 3587a835c8844d3ed6b2a19a45e7aa18ba48f557..e7cbab68eec336bfdd1aa0dc4b021f0c7793dc21 100644
--- go-ethereum/miner/ordering_test.go
+++ op-geth/miner/ordering_test.go
@@ -23,11 +23,11 @@ "math/rand"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
)
func TestTransactionPriceNonceSortLegacy(t *testing.T) {
diff --git go-ethereum/miner/payload_building.go op-geth/miner/payload_building.go
index 719736c4795c03b461a3a8b0fdde6b1cd9495670..0b0aa648c1fdf57a462408fd27b88e4f29b80782 100644
--- go-ethereum/miner/payload_building.go
+++ op-geth/miner/payload_building.go
@@ -19,16 +19,18 @@
import (
"crypto/sha256"
"encoding/binary"
+ "errors"
"math/big"
"sync"
+ "sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/beacon/engine"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/beacon/engine"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
// BuildPayloadArgs contains the provided parameters for building payload.
@@ -42,6 +44,10 @@ Random common.Hash // The provided randomness value
Withdrawals types.Withdrawals // The provided withdrawals
BeaconRoot *common.Hash // The provided beaconRoot (Cancun)
Version engine.PayloadVersion // Versioning byte for payload id calculation.
+
+ NoTxPool bool // Optimism addition: option to disable tx pool contents from being included
+ Transactions []*types.Transaction // Optimism addition: txs forced into the block via engine API
+ GasLimit *uint64 // Optimism addition: override gas limit of the block to build
}
// Id computes an 8-byte identifier by hashing the components of the payload arguments.
@@ -56,6 +62,19 @@ rlp.Encode(hasher, args.Withdrawals)
if args.BeaconRoot != nil {
hasher.Write(args.BeaconRoot[:])
}
+
+ if args.NoTxPool || len(args.Transactions) > 0 { // extend if extra payload attributes are used
+ binary.Write(hasher, binary.BigEndian, args.NoTxPool)
+ binary.Write(hasher, binary.BigEndian, uint64(len(args.Transactions)))
+ for _, tx := range args.Transactions {
+ h := tx.Hash()
+ hasher.Write(h[:])
+ }
+ }
+ if args.GasLimit != nil {
+ binary.Write(hasher, binary.BigEndian, *args.GasLimit)
+ }
+
var out engine.PayloadID
copy(out[:], hasher.Sum(nil)[:8])
out[0] = byte(args.Version)
@@ -76,6 +95,10 @@ fullFees *big.Int
stop chan struct{}
lock sync.Mutex
cond *sync.Cond
+
+ err error
+ stopOnce sync.Once
+ interrupt *atomic.Int32 // interrupt signal shared with worker
}
// newPayload initializes the payload object.
@@ -84,11 +107,15 @@ payload := &Payload{
id: id,
empty: empty,
stop: make(chan struct{}),
+
+ interrupt: new(atomic.Int32),
}
log.Info("Starting work on payload", "id", payload.id)
payload.cond = sync.NewCond(&payload.lock)
return payload
}
+
+var errInterruptedUpdate = errors.New("interrupted payload update")
// update updates the full-block with latest built version.
func (payload *Payload) update(r *newPayloadResult, elapsed time.Duration) {
@@ -100,6 +127,19 @@ case <-payload.stop:
return // reject stale update
default:
}
+
+ defer payload.cond.Broadcast() // fire signal for notifying any full block result
+
+ if errors.Is(r.err, errInterruptedUpdate) {
+ log.Debug("Ignoring interrupted payload update", "id", payload.id)
+ return
+ } else if r.err != nil {
+ log.Warn("Error building payload update", "id", payload.id, "err", r.err)
+ payload.err = r.err // record latest error
+ return
+ }
+ log.Debug("New payload update", "id", payload.id, "elapsed", common.PrettyDuration(elapsed))
+
// Ensure the newly provided full block has a higher transaction fee.
// In post-merge stage, there is no uncle reward anymore and transaction
// fee(apart from the mev revenue) is the only indicator for comparison.
@@ -121,24 +161,12 @@ "root", r.block.Root(),
"elapsed", common.PrettyDuration(elapsed),
)
}
- payload.cond.Broadcast() // fire signal for notifying full block
}
// Resolve returns the latest built payload and also terminates the background
// thread for updating payload. It's safe to be called multiple times.
func (payload *Payload) Resolve() *engine.ExecutionPayloadEnvelope {
- payload.lock.Lock()
- defer payload.lock.Unlock()
-
- select {
- case <-payload.stop:
- default:
- close(payload.stop)
- }
- if payload.full != nil {
- return engine.BlockToExecutableData(payload.full, payload.fullFees, payload.sidecars)
- }
- return engine.BlockToExecutableData(payload.empty, big.NewInt(0), nil)
+ return payload.resolve(false)
}
// ResolveEmpty is basically identical to Resolve, but it expects empty block only.
@@ -153,10 +181,24 @@
// ResolveFull is basically identical to Resolve, but it expects full block only.
// Don't call Resolve until ResolveFull returns, otherwise it might block forever.
func (payload *Payload) ResolveFull() *engine.ExecutionPayloadEnvelope {
+ return payload.resolve(true)
+}
+
+func (payload *Payload) WaitFull() {
+ payload.lock.Lock()
+ defer payload.lock.Unlock()
+ payload.cond.Wait()
+}
+
+func (payload *Payload) resolve(onlyFull bool) *engine.ExecutionPayloadEnvelope {
payload.lock.Lock()
defer payload.lock.Unlock()
- if payload.full == nil {
+ // We interrupt any active building block to prevent it from adding more transactions,
+ // and if it is an update, don't attempt to seal the block.
+ payload.interruptBuilding()
+
+ if payload.full == nil && (onlyFull || payload.empty == nil) {
select {
case <-payload.stop:
return nil
@@ -167,21 +209,82 @@ // forever if Resolve is called in the meantime which
// terminates the background construction process.
payload.cond.Wait()
}
- // Terminate the background payload construction
- select {
- case <-payload.stop:
- default:
- close(payload.stop)
+
+ // Now we can signal the building routine to stop.
+ payload.stopBuilding()
+
+ if payload.full != nil {
+ return engine.BlockToExecutableData(payload.full, payload.fullFees, payload.sidecars)
+ } else if !onlyFull && payload.empty != nil {
+ return engine.BlockToExecutableData(payload.empty, big.NewInt(0), nil)
+ } else if err := payload.err; err != nil {
+ log.Error("Error building any payload", "id", payload.id, "err", err)
}
- return engine.BlockToExecutableData(payload.full, payload.fullFees, payload.sidecars)
+ return nil
+}
+
+// interruptBuilding sets an interrupt for a potentially ongoing
+// block building process.
+// This will prevent it from adding new transactions to the block, and if it is
+// building an update, the block will also not be sealed, as we would discard
+// the update anyways.
+// interruptBuilding is safe to be called concurrently.
+func (payload *Payload) interruptBuilding() {
+ // Set the interrupt if not interrupted already.
+ // It's ok if it has either already been interrupted by payload resolution earlier,
+ // or by the timeout timer set to commitInterruptTimeout.
+ if payload.interrupt.CompareAndSwap(commitInterruptNone, commitInterruptResolve) {
+ log.Debug("Interrupted payload building.", "id", payload.id)
+ } else {
+ log.Debug("Payload building already interrupted.",
+ "id", payload.id, "interrupt", payload.interrupt.Load())
+ }
+}
+
+// stopBuilding signals to the block updating routine to stop. An ongoing payload
+// building job will still complete. It can be interrupted to stop filling new
+// transactions with interruptBuilding.
+// stopBuilding is safe to be called concurrently.
+func (payload *Payload) stopBuilding() {
+ // Concurrent Resolve calls should only stop once.
+ payload.stopOnce.Do(func() {
+ log.Debug("Stop payload building.", "id", payload.id)
+ close(payload.stop)
+ })
}
// buildPayload builds the payload according to the provided parameters.
func (w *worker) buildPayload(args *BuildPayloadArgs) (*Payload, error) {
- // Build the initial version with no transaction included. It should be fast
- // enough to run. The empty payload can at least make sure there is something
- // to deliver for not missing slot.
- emptyParams := &generateParams{
+ if args.NoTxPool { // don't start the background payload updating job if there is no tx pool to pull from
+ // Build the initial version with no transaction included. It should be fast
+ // enough to run. The empty payload can at least make sure there is something
+ // to deliver for not missing slot.
+ // In OP-Stack, the "empty" block is constructed from provided txs only, i.e. no tx-pool usage.
+ emptyParams := &generateParams{
+ timestamp: args.Timestamp,
+ forceTime: true,
+ parentHash: args.Parent,
+ coinbase: args.FeeRecipient,
+ random: args.Random,
+ withdrawals: args.Withdrawals,
+ beaconRoot: args.BeaconRoot,
+ noTxs: true,
+ txs: args.Transactions,
+ gasLimit: args.GasLimit,
+ }
+ empty := w.getSealingBlock(emptyParams)
+ if empty.err != nil {
+ return nil, empty.err
+ }
+ payload := newPayload(empty.block, args.Id())
+ // make sure to make it appear as full, otherwise it will wait indefinitely for payload building to complete.
+ payload.full = empty.block
+ payload.fullFees = empty.fees
+ payload.cond.Broadcast() // unblocks Resolve
+ return payload, nil
+ }
+
+ fullParams := &generateParams{
timestamp: args.Timestamp,
forceTime: true,
parentHash: args.Parent,
@@ -189,15 +292,21 @@ coinbase: args.FeeRecipient,
random: args.Random,
withdrawals: args.Withdrawals,
beaconRoot: args.BeaconRoot,
- noTxs: true,
+ noTxs: false,
+ txs: args.Transactions,
+ gasLimit: args.GasLimit,
}
- empty := w.getSealingBlock(emptyParams)
- if empty.err != nil {
- return nil, empty.err
+
+ // Since we skip building the empty block when using the tx pool, we need to explicitly
+ // validate the BuildPayloadArgs here.
+ blockTime, err := w.validateParams(fullParams)
+ if err != nil {
+ return nil, err
}
- // Construct a payload object for return.
- payload := newPayload(empty.block, args.Id())
+ payload := newPayload(nil, args.Id())
+ // set shared interrupt
+ fullParams.interrupt = payload.interrupt
// Spin up a routine for updating the payload in background. This strategy
// can maximum the revenue for including transactions with highest fee.
@@ -207,36 +316,59 @@ // for triggering process immediately.
timer := time.NewTimer(0)
defer timer.Stop()
- // Setup the timer for terminating the process if SECONDS_PER_SLOT (12s in
- // the Mainnet configuration) have passed since the point in time identified
- // by the timestamp parameter.
- endTimer := time.NewTimer(time.Second * 12)
+ start := time.Now()
+ // Setup the timer for terminating the payload building process as determined
+ // by validateParams.
+ endTimer := time.NewTimer(blockTime)
+ defer endTimer.Stop()
+
+ timeout := time.Now().Add(blockTime)
+
+ stopReason := "delivery"
+ defer func() {
+ log.Info("Stopping work on payload",
+ "id", payload.id,
+ "reason", stopReason,
+ "elapsed", common.PrettyDuration(time.Since(start)))
+ }()
- fullParams := &generateParams{
- timestamp: args.Timestamp,
- forceTime: true,
- parentHash: args.Parent,
- coinbase: args.FeeRecipient,
- random: args.Random,
- withdrawals: args.Withdrawals,
- beaconRoot: args.BeaconRoot,
- noTxs: false,
+ updatePayload := func() time.Duration {
+ start := time.Now()
+ // getSealingBlock is interrupted by shared interrupt
+ r := w.getSealingBlock(fullParams)
+ dur := time.Since(start)
+ // update handles error case
+ payload.update(r, dur)
+ if r.err == nil {
+ // after first successful pass, we're updating
+ fullParams.isUpdate = true
+ }
+ timer.Reset(w.recommit)
+ return dur
}
+ var lastDuration time.Duration
for {
select {
case <-timer.C:
- start := time.Now()
- r := w.getSealingBlock(fullParams)
- if r.err == nil {
- payload.update(r, time.Since(start))
+ // We have to prioritize the stop signal because the recommit timer
+ // might have fired while stop also got closed.
+ select {
+ case <-payload.stop:
+ return
+ default:
}
- timer.Reset(w.recommit)
+ // Assuming last payload building duration as lower bound for next one,
+ // skip new update if we're too close to the timeout anyways.
+ if lastDuration > 0 && time.Now().Add(lastDuration).After(timeout) {
+ stopReason = "near-timeout"
+ return
+ }
+ lastDuration = updatePayload()
case <-payload.stop:
- log.Info("Stopping work on payload", "id", payload.id, "reason", "delivery")
return
case <-endTimer.C:
- log.Info("Stopping work on payload", "id", payload.id, "reason", "timeout")
+ stopReason = "timeout"
return
}
}
diff --git go-ethereum/miner/payload_building_test.go op-geth/miner/payload_building_test.go
index 708072b5ecf2b593d22a6447d535f76618ee8b7f..6611a98183d6b00d2f78e3131bbb13e779917246 100644
--- go-ethereum/miner/payload_building_test.go
+++ op-geth/miner/payload_building_test.go
@@ -17,19 +17,28 @@
package miner
import (
+ "math/big"
"reflect"
"testing"
"time"
- "github.com/ethereum/go-ethereum/beacon/engine"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/beacon/engine"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
func TestBuildPayload(t *testing.T) {
+ t.Run("no-tx-pool", func(t *testing.T) { testBuildPayload(t, true, false) })
+ // no-tx-pool case with interrupt not interesting because no-tx-pool doesn't run
+ // the builder routine
+ t.Run("with-tx-pool", func(t *testing.T) { testBuildPayload(t, false, false) })
+ t.Run("with-tx-pool-interrupt", func(t *testing.T) { testBuildPayload(t, false, true) })
+}
+
+func testBuildPayload(t *testing.T, noTxPool, interrupt bool) {
t.Parallel()
var (
db = rawdb.NewMemoryDatabase()
@@ -37,6 +46,14 @@ recipient = common.HexToAddress("0xdeadbeef")
)
w, b := newTestWorker(t, params.TestChainConfig, ethash.NewFaker(), db, 0)
defer w.close()
+
+ const numInterruptTxs = 256
+ if interrupt {
+ // when doing interrupt testing, create a large pool so interruption will
+ // definitely be visible.
+ txs := genTxs(1, numInterruptTxs)
+ b.txPool.Add(txs, true, false)
+ }
timestamp := uint64(time.Now().Unix())
args := &BuildPayloadArgs{
@@ -44,12 +61,19 @@ Parent: b.chain.CurrentBlock().Hash(),
Timestamp: timestamp,
Random: common.Hash{},
FeeRecipient: recipient,
+ NoTxPool: noTxPool,
}
+ // payload resolution now interrupts block building, so we have to
+ // wait for the payloading building process to build its first block
payload, err := w.buildPayload(args)
if err != nil {
t.Fatalf("Failed to build payload %v", err)
}
verify := func(outer *engine.ExecutionPayloadEnvelope, txs int) {
+ t.Helper()
+ if outer == nil {
+ t.Fatal("ExecutionPayloadEnvelope is nil")
+ }
payload := outer.ExecutionPayload
if payload.ParentHash != b.chain.CurrentBlock().Hash() {
t.Fatal("Unexpected parent hash")
@@ -63,15 +87,27 @@ }
if payload.FeeRecipient != recipient {
t.Fatal("Unexpected fee recipient")
}
- if len(payload.Transactions) != txs {
- t.Fatal("Unexpected transaction set")
+ if !interrupt && len(payload.Transactions) != txs {
+ t.Fatalf("Unexpect transaction set: got %d, expected %d", len(payload.Transactions), txs)
+ } else if interrupt && len(payload.Transactions) >= txs {
+ t.Fatalf("Unexpect transaction set: got %d, expected less than %d", len(payload.Transactions), txs)
}
}
- empty := payload.ResolveEmpty()
- verify(empty, 0)
- full := payload.ResolveFull()
- verify(full, len(pendingTxs))
+ if noTxPool {
+ // we only build the empty block when ignoring the tx pool
+ empty := payload.ResolveEmpty()
+ verify(empty, 0)
+ full := payload.ResolveFull()
+ verify(full, 0)
+ } else if interrupt {
+ full := payload.ResolveFull()
+ verify(full, len(pendingTxs)+numInterruptTxs)
+ } else { // tx-pool and no interrupt
+ payload.WaitFull()
+ full := payload.ResolveFull()
+ verify(full, len(pendingTxs))
+ }
// Ensure resolve can be called multiple times and the
// result should be unchanged
@@ -80,6 +116,22 @@ dataTwo := payload.Resolve()
if !reflect.DeepEqual(dataOne, dataTwo) {
t.Fatal("Unexpected payload data")
}
+}
+
+func genTxs(startNonce, count uint64) types.Transactions {
+ txs := make(types.Transactions, 0, count)
+ signer := types.LatestSigner(params.TestChainConfig)
+ for nonce := startNonce; nonce < startNonce+count; nonce++ {
+ txs = append(txs, types.MustSignNewTx(testBankKey, signer, &types.AccessListTx{
+ ChainID: params.TestChainConfig.ChainID,
+ Nonce: nonce,
+ To: &testUserAddress,
+ Value: big.NewInt(1000),
+ Gas: params.TxGas,
+ GasPrice: big.NewInt(params.InitialBaseFee),
+ }))
+ }
+ return txs
}
func TestPayloadId(t *testing.T) {
diff --git go-ethereum/miner/worker.go op-geth/miner/worker.go
index 9a36106231e9828713c628fb33f9cbaf1003c491..1df496c952d4125c09228092dfda29bc1d5f919e 100644
--- go-ethereum/miner/worker.go
+++ op-geth/miner/worker.go
@@ -17,6 +17,7 @@
package miner
import (
+ "context"
"errors"
"fmt"
"math/big"
@@ -24,20 +25,22 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/misc"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie"
)
const (
@@ -56,7 +59,7 @@ resubmitAdjustChanSize = 10
// minRecommitInterval is the minimal time interval to recreate the sealing block with
// any newly arrived transactions.
- minRecommitInterval = 1 * time.Second
+ minRecommitInterval = 100 * time.Millisecond
// maxRecommitInterval is the maximum time interval to recreate the sealing block with
// any newly arrived transactions.
@@ -78,6 +81,7 @@ var (
errBlockInterruptedByNewHead = errors.New("new head arrived while building block")
errBlockInterruptedByRecommit = errors.New("recommit interrupt while building block")
errBlockInterruptedByTimeout = errors.New("timeout while building block")
+ errBlockInterruptedByResolve = errors.New("payload resolution while building block")
)
// environment is the worker's current environment and holds all
@@ -142,6 +146,7 @@ commitInterruptNone int32 = iota
commitInterruptNewHead
commitInterruptResubmit
commitInterruptTimeout
+ commitInterruptResolve
)
// newWorkReq represents a request for new sealing work submitting with relative interrupt notifier.
@@ -348,6 +353,9 @@
// pending returns the pending state and corresponding block. The returned
// values can be nil in case the pending block is not initialized.
func (w *worker) pending() (*types.Block, *state.StateDB) {
+ if w.chainConfig.Optimism != nil && !w.config.RollupComputePendingBlock {
+ return nil, nil // when not computing the pending block, there is never a pending state
+ }
w.snapshotMu.RLock()
defer w.snapshotMu.RUnlock()
if w.snapshotState == nil {
@@ -359,6 +367,12 @@
// pendingBlock returns pending block. The returned block can be nil in case the
// pending block is not initialized.
func (w *worker) pendingBlock() *types.Block {
+ if w.chainConfig.Optimism != nil && !w.config.RollupComputePendingBlock {
+ // For compatibility when not computing a pending block, we serve the latest block as "pending"
+ headHeader := w.eth.BlockChain().CurrentHeader()
+ headBlock := w.eth.BlockChain().GetBlock(headHeader.Hash(), headHeader.Number.Uint64())
+ return headBlock
+ }
w.snapshotMu.RLock()
defer w.snapshotMu.RUnlock()
return w.snapshotBlock
@@ -367,6 +381,9 @@
// pendingBlockAndReceipts returns pending block and corresponding receipts.
// The returned values can be nil in case the pending block is not initialized.
func (w *worker) pendingBlockAndReceipts() (*types.Block, types.Receipts) {
+ if w.chainConfig.Optimism != nil && !w.config.RollupComputePendingBlock {
+ return nil, nil // when not computing the pending block, there are no pending receipts, and thus no pending logs
+ }
w.snapshotMu.RLock()
defer w.snapshotMu.RUnlock()
return w.snapshotBlock, w.snapshotReceipts
@@ -421,6 +438,19 @@
// newWorkLoop is a standalone goroutine to submit new sealing work upon received events.
func (w *worker) newWorkLoop(recommit time.Duration) {
defer w.wg.Done()
+ if w.chainConfig.Optimism != nil && !w.config.RollupComputePendingBlock {
+ for { // do not update the pending-block, instead drain work without doing it, to keep producers from blocking.
+ select {
+ case <-w.startCh:
+ case <-w.chainHeadCh:
+ case <-w.resubmitIntervalCh:
+ case <-w.resubmitAdjustCh:
+ case <-w.exitCh:
+ return
+ }
+ }
+ }
+
var (
interrupt *atomic.Int32
minRecommit = recommit // minimal resubmit interval specified by user.
@@ -538,6 +568,9 @@ case req := <-w.getWorkCh:
req.result <- w.generateWork(req.params)
case ev := <-w.txsCh:
+ if w.chainConfig.Optimism != nil && !w.config.RollupComputePendingBlock {
+ continue // don't update the pending-block snapshot if we are not computing the pending block
+ }
// Apply transactions to the pending state if we're not sealing
//
// Note all transactions received may not be continuous with transactions
@@ -720,6 +753,15 @@ func (w *worker) makeEnv(parent *types.Header, header *types.Header, coinbase common.Address) (*environment, error) {
// Retrieve the parent state to execute on top and start a prefetcher for
// the miner to speed block sealing up a bit.
state, err := w.chain.StateAt(parent.Root)
+ if err != nil && w.chainConfig.Optimism != nil { // Allow the miner to reorg its own chain arbitrarily deep
+ if historicalBackend, ok := w.eth.(BackendWithHistoricalState); ok {
+ var release tracers.StateReleaseFunc
+ parentBlock := w.eth.BlockChain().GetBlockByHash(parent.Hash())
+ state, release, err = historicalBackend.StateAtBlock(context.Background(), parentBlock, ^uint64(0), nil, false, false)
+ state = state.Copy()
+ release()
+ }
+ }
if err != nil {
return nil, err
}
@@ -933,6 +975,43 @@ random common.Hash // The randomness generated by beacon chain, empty before the merge
withdrawals types.Withdrawals // List of withdrawals to include in block.
beaconRoot *common.Hash // The beacon root (cancun field).
noTxs bool // Flag whether an empty block without any transaction is expected
+
+ txs types.Transactions // Deposit transactions to include at the start of the block
+ gasLimit *uint64 // Optional gas limit override
+ interrupt *atomic.Int32 // Optional interruption signal to pass down to worker.generateWork
+ isUpdate bool // Optional flag indicating that this is building a discardable update
+}
+
+// validateParams validates the given parameters.
+// It currently checks that the parent block is known and that the timestamp is valid,
+// i.e., after the parent block's timestamp.
+// It returns an upper bound of the payload building duration as computed
+// by the difference in block timestamps between the parent and genParams.
+func (w *worker) validateParams(genParams *generateParams) (time.Duration, error) {
+ w.mu.RLock()
+ defer w.mu.RUnlock()
+
+ // Find the parent block for sealing task
+ parent := w.chain.CurrentBlock()
+ if genParams.parentHash != (common.Hash{}) {
+ block := w.chain.GetBlockByHash(genParams.parentHash)
+ if block == nil {
+ return 0, fmt.Errorf("missing parent %v", genParams.parentHash)
+ }
+ parent = block.Header()
+ }
+
+ // Sanity check the timestamp correctness
+ blockTime := int64(genParams.timestamp) - int64(parent.Time)
+ if blockTime <= 0 && genParams.forceTime {
+ return 0, fmt.Errorf("invalid timestamp, parent %d given %d", parent.Time, genParams.timestamp)
+ }
+
+ // minimum payload build time of 2s
+ if blockTime < 2 {
+ blockTime = 2
+ }
+ return time.Duration(blockTime) * time.Second, nil
}
// prepareWork constructs the sealing task according to the given parameters,
@@ -969,7 +1048,7 @@ Time: timestamp,
Coinbase: genParams.coinbase,
}
// Set the extra field.
- if len(w.extra) != 0 {
+ if len(w.extra) != 0 && w.chainConfig.Optimism == nil { // Optimism chains must not set any extra data.
header.Extra = w.extra
}
// Set the randomness field from the beacon chain if it's available.
@@ -978,12 +1057,18 @@ header.MixDigest = genParams.random
}
// Set baseFee and GasLimit if we are on an EIP-1559 chain
if w.chainConfig.IsLondon(header.Number) {
- header.BaseFee = eip1559.CalcBaseFee(w.chainConfig, parent)
+ header.BaseFee = eip1559.CalcBaseFee(w.chainConfig, parent, header.Time)
if !w.chainConfig.IsLondon(parent.Number) {
parentGasLimit := parent.GasLimit * w.chainConfig.ElasticityMultiplier()
header.GasLimit = core.CalcGasLimit(parentGasLimit, w.config.GasCeil)
}
}
+ if genParams.gasLimit != nil { // override gas limit if specified
+ header.GasLimit = *genParams.gasLimit
+ } else if w.chain.Config().Optimism != nil && w.config.GasCeil != 0 {
+ // configure the gas limit of pending blocks with the miner gas limit config when using optimism
+ header.GasLimit = w.config.GasCeil
+ }
// Apply EIP-4844, EIP-4788.
if w.chainConfig.IsCancun(header.Number, header.Time) {
var excessBlobGas uint64
@@ -1011,7 +1096,7 @@ log.Error("Failed to create sealing context", "err", err)
return nil, err
}
if header.ParentBeaconRoot != nil {
- context := core.NewEVMBlockContext(header, w.chain, nil)
+ context := core.NewEVMBlockContext(header, w.chain, nil, w.chainConfig, env.state)
vmenv := vm.NewEVM(context, vm.TxContext{}, env.state, w.chainConfig, vm.Config{})
core.ProcessBeaconBlockRoot(*header.ParentBeaconRoot, vmenv, env.state)
}
@@ -1077,26 +1162,56 @@ return nil
}
// generateWork generates a sealing block based on the given parameters.
-func (w *worker) generateWork(params *generateParams) *newPayloadResult {
- work, err := w.prepareWork(params)
+func (w *worker) generateWork(genParams *generateParams) *newPayloadResult {
+ work, err := w.prepareWork(genParams)
if err != nil {
return &newPayloadResult{err: err}
}
defer work.discard()
+ if work.gasPool == nil {
+ gasLimit := w.config.EffectiveGasCeil
+ if gasLimit == 0 || gasLimit > work.header.GasLimit {
+ gasLimit = work.header.GasLimit
+ }
+ work.gasPool = new(core.GasPool).AddGas(gasLimit)
+ }
- if !params.noTxs {
- interrupt := new(atomic.Int32)
+ misc.EnsureCreate2Deployer(w.chainConfig, work.header.Time, work.state)
+
+ for _, tx := range genParams.txs {
+ from, _ := types.Sender(work.signer, tx)
+ work.state.SetTxContext(tx.Hash(), work.tcount)
+ _, err := w.commitTransaction(work, tx)
+ if err != nil {
+ return &newPayloadResult{err: fmt.Errorf("failed to force-include tx: %s type: %d sender: %s nonce: %d, err: %w", tx.Hash(), tx.Type(), from, tx.Nonce(), err)}
+ }
+ work.tcount++
+ }
+
+ // forced transactions done, fill rest of block with transactions
+ if !genParams.noTxs {
+ // use shared interrupt if present
+ interrupt := genParams.interrupt
+ if interrupt == nil {
+ interrupt = new(atomic.Int32)
+ }
timer := time.AfterFunc(w.newpayloadTimeout, func() {
interrupt.Store(commitInterruptTimeout)
})
- defer timer.Stop()
err := w.fillTransactions(interrupt, work)
+ timer.Stop() // don't need timeout interruption any more
if errors.Is(err, errBlockInterruptedByTimeout) {
log.Warn("Block building is interrupted", "allowance", common.PrettyDuration(w.newpayloadTimeout))
+ } else if errors.Is(err, errBlockInterruptedByResolve) {
+ log.Info("Block building got interrupted by payload resolution")
}
}
- block, err := w.engine.FinalizeAndAssemble(w.chain, work.header, work.state, work.txs, nil, work.receipts, params.withdrawals)
+ if intr := genParams.interrupt; intr != nil && genParams.isUpdate && intr.Load() != commitInterruptNone {
+ return &newPayloadResult{err: errInterruptedUpdate}
+ }
+
+ block, err := w.engine.FinalizeAndAssemble(w.chain, work.header, work.state, work.txs, nil, work.receipts, genParams.withdrawals)
if err != nil {
return &newPayloadResult{err: err}
}
@@ -1182,7 +1297,7 @@ if interval != nil {
interval()
}
// Create a local environment copy, avoid the data race with snapshot state.
- // https://github.com/ethereum/go-ethereum/issues/24299
+ // https://github.com/tenderly/op-geth/issues/24299
env := env.copy()
// Withdrawals are set to nil here, because this is only called in PoW.
block, err := w.engine.FinalizeAndAssemble(w.chain, env.header, env.state, env.txs, nil, env.receipts, nil)
@@ -1272,6 +1387,8 @@ case commitInterruptResubmit:
return errBlockInterruptedByRecommit
case commitInterruptTimeout:
return errBlockInterruptedByTimeout
+ case commitInterruptResolve:
+ return errBlockInterruptedByResolve
default:
panic(fmt.Errorf("undefined signal %d", signal))
}
diff --git go-ethereum/miner/worker_test.go op-geth/miner/worker_test.go
index 9dba12ae51a26b94888a2e3edb874f211c6ff9e9..1ef2c12b75f39a99a97cfbbfe0e0859d233173e0 100644
--- go-ethereum/miner/worker_test.go
+++ op-geth/miner/worker_test.go
@@ -22,22 +22,22 @@ "sync/atomic"
"testing"
"time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/clique"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/txpool/legacypool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/clique"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/txpool/legacypool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/params"
)
const (
@@ -303,7 +303,8 @@ min := float64(3 * time.Second.Nanoseconds())
estimate = estimate*(1-intervalAdjustRatio) + intervalAdjustRatio*(min-intervalAdjustBias)
wantMinInterval, wantRecommitInterval = 3*time.Second, time.Duration(estimate)*time.Nanosecond
case 3:
- wantMinInterval, wantRecommitInterval = time.Second, time.Second
+ // lower than upstream test, since enforced min recommit interval is lower
+ wantMinInterval, wantRecommitInterval = 500*time.Millisecond, 500*time.Millisecond
}
// Check interval
Tx-pool tx cost updates
+260
-127
Transaction queueing and inclusion needs to account for the L1 cost component.
diff --git go-ethereum/core/txpool/blobpool/blobpool.go op-geth/core/txpool/blobpool/blobpool.go
index 3ed698c1b18fcc4bfa0d8622208917cdd7c1ad33..cf119e8dbdd6f6bc8ee6f03ddb1e966d4adb29df 100644
--- go-ethereum/core/txpool/blobpool/blobpool.go
+++ op-geth/core/txpool/blobpool/blobpool.go
@@ -29,20 +29,20 @@ "sort"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/holiman/billy"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
const (
@@ -401,7 +401,7 @@ for addr := range p.index {
p.recheck(addr, nil)
}
var (
- basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), p.head))
+ basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), p.head, p.head.Time+1))
blobfee = uint256.NewInt(params.BlobTxMinBlobGasprice)
)
if p.head.ExcessBlobGas != nil {
@@ -822,7 +822,7 @@ p.limbo.finalize(p.chain.CurrentFinalBlock())
}
// Reset the price heap for the new set of basefee/blobfee pairs
var (
- basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), newHead))
+ basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), newHead, newHead.Time+1))
blobfee = uint256.MustFromBig(big.NewInt(params.BlobTxMinBlobGasprice))
)
if newHead.ExcessBlobGas != nil {
diff --git go-ethereum/core/txpool/blobpool/blobpool_test.go op-geth/core/txpool/blobpool/blobpool_test.go
index f7644c1d0ab61c8faa954c668da30abf20e3d8ee..64260c80fb11cb67906ac889049af88e75396da2 100644
--- go-ethereum/core/txpool/blobpool/blobpool_test.go
+++ op-geth/core/txpool/blobpool/blobpool_test.go
@@ -29,22 +29,22 @@ "sync"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
- "github.com/ethereum/go-ethereum/ethdb/memorydb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/holiman/billy"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/ethdb/memorydb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
var (
@@ -102,7 +102,7 @@ Number: blockNumber,
GasLimit: gasLimit,
GasUsed: 0,
BaseFee: mid,
- }).Cmp(bc.basefee.ToBig()) > 0 {
+ }, blockTime).Cmp(bc.basefee.ToBig()) > 0 {
hi = mid
} else {
lo = mid
diff --git go-ethereum/core/txpool/blobpool/config.go op-geth/core/txpool/blobpool/config.go
index 1d180739cdfb0c5d569f414bfc8e9c6268849cda..b8058325ef9e256b4ba239da85c32e6ef2580eed 100644
--- go-ethereum/core/txpool/blobpool/config.go
+++ op-geth/core/txpool/blobpool/config.go
@@ -17,7 +17,7 @@
package blobpool
import (
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
// Config are the configuration parameters of the blob transaction pool.
diff --git go-ethereum/core/txpool/blobpool/evictheap.go op-geth/core/txpool/blobpool/evictheap.go
index bc4543a352e2888eba1aee78853c2c5c2b7735cb..82ed633d839f48a6f21a0262550070ab4e6f9fe7 100644
--- go-ethereum/core/txpool/blobpool/evictheap.go
+++ op-geth/core/txpool/blobpool/evictheap.go
@@ -22,8 +22,8 @@ "container/heap"
"math"
"sort"
- "github.com/ethereum/go-ethereum/common"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
)
// evictHeap is a helper data structure to keep track of the cheapest bottleneck
diff --git go-ethereum/core/txpool/blobpool/evictheap_test.go op-geth/core/txpool/blobpool/evictheap_test.go
index 01b136551cf2a6036632d52aa06a62c5b6d0f6e5..df711c61a51a1149e1e030ebc8f57f82459b0de1 100644
--- go-ethereum/core/txpool/blobpool/evictheap_test.go
+++ op-geth/core/txpool/blobpool/evictheap_test.go
@@ -21,9 +21,9 @@ "container/heap"
mrand "math/rand"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/params"
)
var rand = mrand.New(mrand.NewSource(1))
diff --git go-ethereum/core/txpool/blobpool/interface.go op-geth/core/txpool/blobpool/interface.go
index 6f296a54bd63d35e0cb2b1dec904434da2627a85..29ee75a81f23f982ef1900197c45c7b99c8c6bc6 100644
--- go-ethereum/core/txpool/blobpool/interface.go
+++ op-geth/core/txpool/blobpool/interface.go
@@ -17,10 +17,10 @@
package blobpool
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
// BlockChain defines the minimal set of methods needed to back a blob pool with
diff --git go-ethereum/core/txpool/blobpool/limbo.go op-geth/core/txpool/blobpool/limbo.go
index ec754f6894ec5565a0eea65e23312ab5258ba191..2804cde223fb26054749a1aa770edb455200ad04 100644
--- go-ethereum/core/txpool/blobpool/limbo.go
+++ op-geth/core/txpool/blobpool/limbo.go
@@ -19,11 +19,11 @@
import (
"errors"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/holiman/billy"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
)
// limboBlob is a wrapper around an opaque blobset that also contains the tx hash
diff --git go-ethereum/core/txpool/blobpool/metrics.go op-geth/core/txpool/blobpool/metrics.go
index 52419ade0978aead6ec00b32497d519cbbf77b9f..962dc521d9fa58d629783dc302d72ecac29239f4 100644
--- go-ethereum/core/txpool/blobpool/metrics.go
+++ op-geth/core/txpool/blobpool/metrics.go
@@ -16,7 +16,7 @@ // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
package blobpool
-import "github.com/ethereum/go-ethereum/metrics"
+import "github.com/tenderly/op-geth/metrics"
var (
// datacapGauge tracks the user's configured capacity for the blob pool. It
diff --git go-ethereum/core/txpool/legacypool/journal.go op-geth/core/txpool/legacypool/journal.go
index 899ed00bcced76d429837eb00bdcec8f400697e1..58fddc2c07abbc9136e049fb25192cdf8cf41daf 100644
--- go-ethereum/core/txpool/legacypool/journal.go
+++ op-geth/core/txpool/legacypool/journal.go
@@ -22,10 +22,10 @@ "io"
"io/fs"
"os"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
)
// errNoActiveJournal is returned if a transaction is attempted to be inserted
diff --git go-ethereum/core/txpool/legacypool/legacypool.go op-geth/core/txpool/legacypool/legacypool.go
index 4e1d26acf4056712a3a4bff2f8bc796fc81f8759..a9cec211e567cb551fd75d47190e4523b854bea3 100644
--- go-ethereum/core/txpool/legacypool/legacypool.go
+++ op-geth/core/txpool/legacypool/legacypool.go
@@ -26,18 +26,18 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/prque"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/prque"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/params"
)
const (
@@ -126,6 +126,10 @@ NoLocals bool // Whether local transaction handling should be disabled
Journal string // Journal of local transactions to survive node restarts
Rejournal time.Duration // Time interval to regenerate the local transaction journal
+ // JournalRemote controls whether journaling includes remote transactions or not.
+ // When true, all transactions loaded from the journal are treated as remote.
+ JournalRemote bool
+
PriceLimit uint64 // Minimum gas price to enforce for acceptance into the pool
PriceBump uint64 // Minimum price bump percentage to replace an already existing transaction (nonce)
@@ -135,6 +139,8 @@ AccountQueue uint64 // Maximum number of non-executable transaction slots permitted per account
GlobalQueue uint64 // Maximum number of non-executable transaction slots for all accounts
Lifetime time.Duration // Maximum amount of time non-executable transaction are queued
+
+ EffectiveGasCeil uint64 // if non-zero, a gas ceiling to enforce independent of the header's gaslimit value
}
// DefaultConfig contains the default configurations for the transaction pool.
@@ -231,6 +237,8 @@ wg sync.WaitGroup // tracks loop, scheduleReorgLoop
initDoneCh chan struct{} // is closed once the pool is initialized (for tests)
changesSinceReorg int // A counter for how many drops we've performed in-between reorg.
+
+ l1CostFn txpool.L1CostFunc // To apply L1 costs as rollup, optional field, may be nil.
}
type txpoolResetRequest struct {
@@ -267,7 +275,7 @@ pool.locals.add(addr)
}
pool.priced = newPricedList(pool.all)
- if !config.NoLocals && config.Journal != "" {
+ if (!config.NoLocals || config.JournalRemote) && config.Journal != "" {
pool.journal = newTxJournal(config.Journal)
}
return pool
@@ -316,10 +324,14 @@ go pool.scheduleReorgLoop()
// If local transactions and journaling is enabled, load from disk
if pool.journal != nil {
- if err := pool.journal.load(pool.addLocals); err != nil {
+ add := pool.addLocals
+ if pool.config.JournalRemote {
+ add = pool.addRemotesSync // Use sync version to match pool.AddLocals
+ }
+ if err := pool.journal.load(add); err != nil {
log.Warn("Failed to load transaction journal", "err", err)
}
- if err := pool.journal.rotate(pool.local()); err != nil {
+ if err := pool.journal.rotate(pool.toJournal()); err != nil {
log.Warn("Failed to rotate transaction journal", "err", err)
}
}
@@ -389,7 +401,7 @@ // Handle local transaction journal rotation
case <-journal.C:
if pool.journal != nil {
pool.mu.Lock()
- if err := pool.journal.rotate(pool.local()); err != nil {
+ if err := pool.journal.rotate(pool.toJournal()); err != nil {
log.Warn("Failed to rotate local tx journal", "err", err)
}
pool.mu.Unlock()
@@ -583,6 +595,23 @@
return pool.locals.flatten()
}
+// toJournal retrieves all transactions that should be included in the journal,
+// grouped by origin account and sorted by nonce.
+// The returned transaction set is a copy and can be freely modified by calling code.
+func (pool *LegacyPool) toJournal() map[common.Address]types.Transactions {
+ if !pool.config.JournalRemote {
+ return pool.local()
+ }
+ txs := make(map[common.Address]types.Transactions)
+ for addr, pending := range pool.pending {
+ txs[addr] = append(txs[addr], pending.Flatten()...)
+ }
+ for addr, queued := range pool.queue {
+ txs[addr] = append(txs[addr], queued.Flatten()...)
+ }
+ return txs
+}
+
// local retrieves all currently known local transactions, grouped by origin
// account and sorted by nonce. The returned transaction set is a copy and can be
// freely modified by calling code.
@@ -610,8 +639,9 @@ Accept: 0 |
1<<types.LegacyTxType |
1<<types.AccessListTxType |
1<<types.DynamicFeeTxType,
- MaxSize: txMaxSize,
- MinTip: pool.gasTip.Load().ToBig(),
+ MaxSize: txMaxSize,
+ MinTip: pool.gasTip.Load().ToBig(),
+ EffectiveGasCeil: pool.config.EffectiveGasCeil,
}
if local {
opts.MinTip = new(big.Int)
@@ -648,11 +678,18 @@ },
ExistingCost: func(addr common.Address, nonce uint64) *big.Int {
if list := pool.pending[addr]; list != nil {
if tx := list.txs.Get(nonce); tx != nil {
- return tx.Cost()
+ cost := tx.Cost()
+ if pool.l1CostFn != nil {
+ if l1Cost := pool.l1CostFn(tx.RollupCostData()); l1Cost != nil { // add rollup cost
+ cost = cost.Add(cost, l1Cost)
+ }
+ }
+ return cost
}
}
return nil
},
+ L1CostFn: pool.l1CostFn,
}
if err := txpool.ValidateTransactionWithState(tx, pool.signer, opts); err != nil {
return err
@@ -775,7 +812,7 @@
// Try to replace an existing transaction in the pending pool
if list := pool.pending[from]; list != nil && list.Contains(tx.Nonce()) {
// Nonce already pending, check if required price bump is met
- inserted, old := list.Add(tx, pool.config.PriceBump)
+ inserted, old := list.Add(tx, pool.config.PriceBump, pool.l1CostFn)
if !inserted {
pendingDiscardMeter.Mark(1)
return false, txpool.ErrReplaceUnderpriced
@@ -849,7 +886,7 @@ from, _ := types.Sender(pool.signer, tx) // already validated
if pool.queue[from] == nil {
pool.queue[from] = newList(false)
}
- inserted, old := pool.queue[from].Add(tx, pool.config.PriceBump)
+ inserted, old := pool.queue[from].Add(tx, pool.config.PriceBump, pool.l1CostFn)
if !inserted {
// An older transaction was better, discard this
queuedDiscardMeter.Mark(1)
@@ -884,7 +921,7 @@ // journalTx adds the specified transaction to the local disk journal if it is
// deemed to have been sent from a local account.
func (pool *LegacyPool) journalTx(from common.Address, tx *types.Transaction) {
// Only journal if it's enabled and the transaction is local
- if pool.journal == nil || !pool.locals.contains(from) {
+ if pool.journal == nil || (!pool.config.JournalRemote && !pool.locals.contains(from)) {
return
}
if err := pool.journal.insert(tx); err != nil {
@@ -903,7 +940,7 @@ pool.pending[addr] = newList(true)
}
list := pool.pending[addr]
- inserted, old := list.Add(tx, pool.config.PriceBump)
+ inserted, old := list.Add(tx, pool.config.PriceBump, pool.l1CostFn)
if !inserted {
// An older transaction was better, discard this
pool.all.Remove(hash)
@@ -1298,7 +1335,7 @@ if reset != nil {
pool.demoteUnexecutables()
if reset.newHead != nil {
if pool.chainconfig.IsLondon(new(big.Int).Add(reset.newHead.Number, big.NewInt(1))) {
- pendingBaseFee := eip1559.CalcBaseFee(pool.chainconfig, reset.newHead)
+ pendingBaseFee := eip1559.CalcBaseFee(pool.chainconfig, reset.newHead, reset.newHead.Time+1)
pool.priced.SetBaseFee(pendingBaseFee)
} else {
pool.priced.Reheap()
@@ -1430,12 +1467,36 @@ pool.currentHead.Store(newHead)
pool.currentState = statedb
pool.pendingNonces = newNoncer(statedb)
+ if costFn := types.NewL1CostFunc(pool.chainconfig, statedb); costFn != nil {
+ pool.l1CostFn = func(rollupCostData types.RollupCostData) *big.Int {
+ return costFn(rollupCostData, newHead.Time)
+ }
+ }
+
// Inject any transactions discarded due to reorgs
log.Debug("Reinjecting stale transactions", "count", len(reinject))
core.SenderCacher.Recover(pool.signer, reinject)
pool.addTxsLocked(reinject, false)
}
+// reduceBalanceByL1Cost returns the given balance, reduced by the L1Cost of the first transaction in list if applicable
+// Other txs will get filtered out necessary.
+func (pool *LegacyPool) reduceBalanceByL1Cost(list *list, balance *uint256.Int) *uint256.Int {
+ if !list.Empty() && pool.l1CostFn != nil {
+ el := list.txs.FirstElement()
+ if l1Cost := pool.l1CostFn(el.RollupCostData()); l1Cost != nil {
+ l1Cost256 := uint256.MustFromBig(l1Cost)
+ if l1Cost256.Cmp(balance) >= 0 {
+ // Avoid underflow
+ balance = uint256.NewInt(0)
+ } else {
+ balance = new(uint256.Int).Sub(balance, l1Cost256)
+ }
+ }
+ }
+ return balance
+}
+
// promoteExecutables moves transactions that have become processable from the
// future queue to the set of pending transactions. During this process, all
// invalidated transactions (low nonce, low balance) are deleted.
@@ -1444,7 +1505,7 @@ // Track the promoted transactions to broadcast them at once
var promoted []*types.Transaction
// Iterate over all accounts and promote any executable transactions
- gasLimit := pool.currentHead.Load().GasLimit
+ gasLimit := txpool.EffectiveGasLimit(pool.chainconfig, pool.currentHead.Load().GasLimit, pool.config.EffectiveGasCeil)
for _, addr := range accounts {
list := pool.queue[addr]
if list == nil {
@@ -1457,8 +1518,10 @@ hash := tx.Hash()
pool.all.Remove(hash)
}
log.Trace("Removed old queued transactions", "count", len(forwards))
+ balance := pool.currentState.GetBalance(addr)
+ balance = pool.reduceBalanceByL1Cost(list, balance)
// Drop all transactions that are too costly (low balance or out of gas)
- drops, _ := list.Filter(pool.currentState.GetBalance(addr), gasLimit)
+ drops, _ := list.Filter(balance, gasLimit)
for _, tx := range drops {
hash := tx.Hash()
pool.all.Remove(hash)
@@ -1647,7 +1710,7 @@ // is always explicitly triggered by SetBaseFee and it would be unnecessary and wasteful
// to trigger a re-heap is this function
func (pool *LegacyPool) demoteUnexecutables() {
// Iterate over all accounts and demote any non-executable transactions
- gasLimit := pool.currentHead.Load().GasLimit
+ gasLimit := txpool.EffectiveGasLimit(pool.chainconfig, pool.currentHead.Load().GasLimit, pool.config.EffectiveGasCeil)
for addr, list := range pool.pending {
nonce := pool.currentState.GetNonce(addr)
@@ -1658,8 +1721,10 @@ hash := tx.Hash()
pool.all.Remove(hash)
log.Trace("Removed old pending transaction", "hash", hash)
}
+ balance := pool.currentState.GetBalance(addr)
+ balance = pool.reduceBalanceByL1Cost(list, balance)
// Drop all transactions that are too costly (low balance or out of gas), and queue any invalids back for later
- drops, invalids := list.Filter(pool.currentState.GetBalance(addr), gasLimit)
+ drops, invalids := list.Filter(balance, gasLimit)
for _, tx := range drops {
hash := tx.Hash()
log.Trace("Removed unpayable pending transaction", "hash", hash)
diff --git go-ethereum/core/txpool/legacypool/legacypool2_test.go op-geth/core/txpool/legacypool/legacypool2_test.go
index c8d3a76b83fff0fa01a6493f48192476fed8eb94..fca42b6280a64cd6c10eed46034ae2adf18c5382 100644
--- go-ethereum/core/txpool/legacypool/legacypool2_test.go
+++ op-geth/core/txpool/legacypool/legacypool2_test.go
@@ -20,13 +20,13 @@ "crypto/ecdsa"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/event"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/event"
)
func pricedValuedTransaction(nonce uint64, value int64, gaslimit uint64, gasprice *big.Int, key *ecdsa.PrivateKey) *types.Transaction {
diff --git go-ethereum/core/txpool/legacypool/legacypool_test.go op-geth/core/txpool/legacypool/legacypool_test.go
index 7ffbf745bb8e954271132df7c2f552e695477be1..68b116d801036e42ad38ef63a8faf3b6f53291c7 100644
--- go-ethereum/core/txpool/legacypool/legacypool_test.go
+++ op-geth/core/txpool/legacypool/legacypool_test.go
@@ -29,17 +29,17 @@ "sync/atomic"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie"
)
var (
@@ -2343,10 +2343,13 @@ }
// Tests that local transactions are journaled to disk, but remote transactions
// get discarded between restarts.
-func TestJournaling(t *testing.T) { testJournaling(t, false) }
-func TestJournalingNoLocals(t *testing.T) { testJournaling(t, true) }
+func TestJournaling(t *testing.T) { testJournaling(t, false, false) }
+func TestJournalingNoLocals(t *testing.T) { testJournaling(t, true, false) }
+
+func TestJournalingRemotes(t *testing.T) { testJournaling(t, false, true) }
+func TestJournalingRemotesNoLocals(t *testing.T) { testJournaling(t, true, true) }
-func testJournaling(t *testing.T, nolocals bool) {
+func testJournaling(t *testing.T, nolocals bool, journalRemotes bool) {
t.Parallel()
// Create a temporary file for the journal
@@ -2367,6 +2370,7 @@ blockchain := newTestBlockChain(params.TestChainConfig, 1000000, statedb, new(event.Feed))
config := testTxPoolConfig
config.NoLocals = nolocals
+ config.JournalRemote = journalRemotes
config.Journal = journal
config.Rejournal = time.Second
@@ -2415,10 +2419,14 @@ pending, queued = pool.Stats()
if queued != 0 {
t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 0)
}
- if nolocals {
+ if nolocals && !journalRemotes {
if pending != 0 {
t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 0)
}
+ } else if journalRemotes {
+ if pending != 3 {
+ t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 3)
+ }
} else {
if pending != 2 {
t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 2)
@@ -2439,10 +2447,16 @@ pool = New(config, blockchain)
pool.Init(config.PriceLimit, blockchain.CurrentBlock(), makeAddressReserver())
pending, queued = pool.Stats()
- if pending != 0 {
- t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 0)
+ if journalRemotes {
+ if pending != 1 { // Remove the 2 replaced local transactions, but preserve the remote
+ t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 1)
+ }
+ } else {
+ if pending != 0 {
+ t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 0)
+ }
}
- if nolocals {
+ if nolocals && !journalRemotes {
if queued != 0 {
t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 0)
}
diff --git go-ethereum/core/txpool/legacypool/list.go op-geth/core/txpool/legacypool/list.go
index 7db9c98ace638b979e0d2f6f257526d714015f2e..64e6dedf10312ed8a399d3cbc73de114282a638e 100644
--- go-ethereum/core/txpool/legacypool/list.go
+++ op-geth/core/txpool/legacypool/list.go
@@ -25,9 +25,10 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
"golang.org/x/exp/slices"
)
@@ -265,6 +266,15 @@ cache := m.flatten()
return cache[len(cache)-1]
}
+// FirstElement returns the first element from the heap (guaranteed to be lowest), thus, the
+// transaction with the lowest nonce. Returns nil if there are no elements.
+func (m *sortedMap) FirstElement() *types.Transaction {
+ if m.Len() == 0 {
+ return nil
+ }
+ return m.Get((*m.index)[0])
+}
+
// list is a "list" of transactions belonging to an account, sorted by account
// nonce. The same type can be used both for storing contiguous transactions for
// the executable/pending queue; and for storing gapped transactions for the non-
@@ -300,7 +310,7 @@ // transaction was accepted, and if yes, any previous transaction it replaced.
//
// If the new transaction is accepted into the list, the lists' cost and gas
// thresholds are also potentially updated.
-func (l *list) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Transaction) {
+func (l *list) Add(tx *types.Transaction, priceBump uint64, l1CostFn txpool.L1CostFunc) (bool, *types.Transaction) {
// If there's an older better transaction, abort
old := l.txs.Get(tx.Nonce())
if old != nil {
@@ -332,7 +342,11 @@ if overflow {
return false, nil
}
l.totalcost.Add(l.totalcost, cost)
-
+ if l1CostFn != nil {
+ if l1Cost := l1CostFn(tx.RollupCostData()); l1Cost != nil { // add rollup cost
+ l.totalcost.Add(l.totalcost, cost)
+ }
+ }
// Otherwise overwrite the old transaction with the current one
l.txs.Put(tx)
if l.costcap.Cmp(cost) < 0 {
diff --git go-ethereum/core/txpool/legacypool/list_test.go op-geth/core/txpool/legacypool/list_test.go
index 8587c66f7d22a07f5776d7e25f90499eddc239cc..dc46b3a8edcbb2d8d1082fd077c1b5592e0dbf8e 100644
--- go-ethereum/core/txpool/legacypool/list_test.go
+++ op-geth/core/txpool/legacypool/list_test.go
@@ -21,10 +21,10 @@ "math/big"
"math/rand"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
)
// Tests that transactions can be added to strict lists and list contents and
@@ -40,7 +40,7 @@ }
// Insert the transactions in a random order
list := newList(true)
for _, v := range rand.Perm(len(txs)) {
- list.Add(txs[v], DefaultConfig.PriceBump)
+ list.Add(txs[v], DefaultConfig.PriceBump, nil)
}
// Verify internal state
if len(list.txs.items) != len(txs) {
@@ -64,7 +64,7 @@ gasprice, _ := new(big.Int).SetString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 0)
gaslimit := uint64(i)
tx, _ := types.SignTx(types.NewTransaction(uint64(i), common.Address{}, value, gaslimit, gasprice, nil), types.HomesteadSigner{}, key)
t.Logf("cost: %x bitlen: %d\n", tx.Cost(), tx.Cost().BitLen())
- list.Add(tx, DefaultConfig.PriceBump)
+ list.Add(tx, DefaultConfig.PriceBump, nil)
}
}
@@ -82,7 +82,7 @@ b.ResetTimer()
for i := 0; i < b.N; i++ {
list := newList(true)
for _, v := range rand.Perm(len(txs)) {
- list.Add(txs[v], DefaultConfig.PriceBump)
+ list.Add(txs[v], DefaultConfig.PriceBump, nil)
list.Filter(priceLimit, DefaultConfig.PriceBump)
}
}
@@ -102,7 +102,7 @@ for i := 0; i < b.N; i++ {
list := newList(true)
// Insert the transactions in a random order
for _, v := range rand.Perm(len(txs)) {
- list.Add(txs[v], DefaultConfig.PriceBump)
+ list.Add(txs[v], DefaultConfig.PriceBump, nil)
}
b.StartTimer()
list.Cap(list.Len() - 1)
diff --git go-ethereum/core/txpool/legacypool/noncer.go op-geth/core/txpool/legacypool/noncer.go
index 2c65dd2caea7f88fd275199873250c7c04742760..0a20a65f2caca706eb88dab6ba6fc5013567feb4 100644
--- go-ethereum/core/txpool/legacypool/noncer.go
+++ op-geth/core/txpool/legacypool/noncer.go
@@ -19,8 +19,8 @@
import (
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/state"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/state"
)
// noncer is a tiny virtual state database to manage the executable nonces of
diff --git go-ethereum/core/txpool/subpool.go op-geth/core/txpool/subpool.go
index 9881ed1b8f960f0a61b7666a5a22412fa0228779..fbdbaef08c96f2d8cefeb7680b584868d607e7f1 100644
--- go-ethereum/core/txpool/subpool.go
+++ op-geth/core/txpool/subpool.go
@@ -20,11 +20,11 @@ import (
"math/big"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/event"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/event"
)
// LazyTransaction contains a small subset of the transaction properties that is
diff --git go-ethereum/core/txpool/txpool.go op-geth/core/txpool/txpool.go
index be7435247d92749027ccbee4e92f0d44153b4a4b..9116fbc06d3ab2426c6d750ce178ca60859ac452 100644
--- go-ethereum/core/txpool/txpool.go
+++ op-geth/core/txpool/txpool.go
@@ -22,13 +22,15 @@ "fmt"
"math/big"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
+
+type L1CostFunc func(dataGas types.RollupCostData) *big.Int
// TxStatus is the current status of a transaction as seen by the pool.
type TxStatus uint
diff --git go-ethereum/core/txpool/validation.go op-geth/core/txpool/validation.go
index 8913859e846e73c032120dd9110791e6a1954d9d..69f0036d9b703244860636d5be441abc2cc155c1 100644
--- go-ethereum/core/txpool/validation.go
+++ op-geth/core/txpool/validation.go
@@ -21,21 +21,40 @@ "crypto/sha256"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
)
+// L1 Info Gas Overhead is the amount of gas the the L1 info deposit consumes.
+// It is removed from the tx pool max gas to better indicate that L2 transactions
+// are not able to consume all of the gas in a L2 block as the L1 info deposit is always present.
+const l1InfoGasOverhead = uint64(70_000)
+
var (
// blobTxMinBlobGasPrice is the big.Int version of the configured protocol
// parameter to avoid constucting a new big integer for every transaction.
blobTxMinBlobGasPrice = big.NewInt(params.BlobTxMinBlobGasprice)
)
+func EffectiveGasLimit(chainConfig *params.ChainConfig, gasLimit uint64, effectiveLimit uint64) uint64 {
+ if effectiveLimit != 0 && effectiveLimit < gasLimit {
+ gasLimit = effectiveLimit
+ }
+ if chainConfig.Optimism != nil {
+ if l1InfoGasOverhead < gasLimit {
+ gasLimit -= l1InfoGasOverhead
+ } else {
+ gasLimit = 0
+ }
+ }
+ return gasLimit
+}
+
// ValidationOptions define certain differences between transaction validation
// across the different pools without having to duplicate those checks.
type ValidationOptions struct {
@@ -44,6 +63,8 @@
Accept uint8 // Bitmap of transaction types that should be accepted for the calling pool
MaxSize uint64 // Maximum size of a transaction that the caller can meaningfully handle
MinTip *big.Int // Minimum gas tip needed to allow a transaction into the caller pool
+
+ EffectiveGasCeil uint64 // if non-zero, a gas ceiling to enforce independent of the header's gaslimit value
}
// ValidateTransaction is a helper method to check whether a transaction is valid
@@ -53,6 +74,15 @@ //
// This check is public to allow different transaction pools to check the basic
// rules without duplicating code and running the risk of missed updates.
func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types.Signer, opts *ValidationOptions) error {
+ // No unauthenticated deposits allowed in the transaction pool.
+ // This is for spam protection, not consensus,
+ // as the external engine-API user authenticates deposits.
+ if tx.Type() == types.DepositTxType {
+ return core.ErrTxTypeNotSupported
+ }
+ if opts.Config.IsOptimism() && tx.Type() == types.BlobTxType {
+ return core.ErrTxTypeNotSupported
+ }
// Ensure transactions not implemented by the calling pool are rejected
if opts.Accept&(1<<tx.Type()) == 0 {
return fmt.Errorf("%w: tx type %v not supported by this pool", core.ErrTxTypeNotSupported, tx.Type())
@@ -82,7 +112,7 @@ if tx.Value().Sign() < 0 {
return ErrNegativeValue
}
// Ensure the transaction doesn't exceed the current block limit gas
- if head.GasLimit < tx.Gas() {
+ if EffectiveGasLimit(opts.Config, head.GasLimit, opts.EffectiveGasCeil) < tx.Gas() {
return ErrGasLimit
}
// Sanity check for extremely large numbers (supported by RLP or RPC)
@@ -191,6 +221,9 @@
// ExistingCost is a mandatory callback to retrieve an already pooled
// transaction's cost with the given nonce to check for overdrafts.
ExistingCost func(addr common.Address, nonce uint64) *big.Int
+
+ // L1CostFn is an optional extension, to validate L1 rollup costs of a tx
+ L1CostFn L1CostFunc
}
// ValidateTransactionWithState is a helper method to check whether a transaction
@@ -221,6 +254,11 @@ var (
balance = opts.State.GetBalance(from).ToBig()
cost = tx.Cost()
)
+ if opts.L1CostFn != nil {
+ if l1Cost := opts.L1CostFn(tx.RollupCostData()); l1Cost != nil { // add rollup cost
+ cost = cost.Add(cost, l1Cost)
+ }
+ }
if balance.Cmp(cost) < 0 {
return fmt.Errorf("%w: balance %v, tx cost %v, overshot %v", core.ErrInsufficientFunds, balance, cost, new(big.Int).Sub(cost, balance))
}
Chain Configuration
+660
-46
Chain config
+247
-21
The rollup functionality is enabled with the optimism field in the chain config.
The EIP-1559 parameters are configurable to adjust for faster more frequent and smaller blocks.
The parameters can be overriden for testing.
diff --git go-ethereum/core/genesis.go op-geth/core/genesis.go
index 54570ac61e4c7d3de57a00ad9e34d22aa02a18a3..9b01062fe9eeb026c80139d8dab7eba62f225d75 100644
--- go-ethereum/core/genesis.go
+++ op-geth/core/genesis.go
@@ -24,21 +24,23 @@ "fmt"
"math/big"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
+ "github.com/ethereum-optimism/superchain-registry/superchain"
+
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
)
//go:generate go run github.com/fjl/gencodec -type Genesis -field-override genesisSpecMarshaling -out gen_genesis.go
@@ -72,6 +74,11 @@ ParentHash common.Hash `json:"parentHash"`
BaseFee *big.Int `json:"baseFeePerGas"` // EIP-1559
ExcessBlobGas *uint64 `json:"excessBlobGas"` // EIP-4844
BlobGasUsed *uint64 `json:"blobGasUsed"` // EIP-4844
+
+ // StateHash represents the genesis state, to allow instantiation of a chain with missing initial state.
+ // Chains with history pruning, or extraordinarily large genesis allocation (e.g. after a regenesis event)
+ // may utilize this to get started, and then state-sync the latest state, while still verifying the header chain.
+ StateHash *common.Hash `json:"stateHash,omitempty"`
}
func ReadGenesis(db ethdb.Database) (*Genesis, error) {
@@ -108,6 +115,10 @@ genesis.Coinbase = genesisHeader.Coinbase
genesis.BaseFee = genesisHeader.BaseFee
genesis.ExcessBlobGas = genesisHeader.ExcessBlobGas
genesis.BlobGasUsed = genesisHeader.BlobGasUsed
+ if genesis.Alloc == nil {
+ h := genesisHeader.Hash()
+ genesis.StateHash = &h
+ }
return &genesis, nil
}
@@ -210,6 +221,12 @@ // ChainOverrides contains the changes to chain config.
type ChainOverrides struct {
OverrideCancun *uint64
OverrideVerkle *uint64
+ // optimism
+ OverrideOptimismCanyon *uint64
+ OverrideOptimismEcotone *uint64
+ OverrideOptimismFjord *uint64
+ ApplySuperchainUpgrades bool
+ OverrideOptimismInterop *uint64
}
// SetupGenesisBlock writes or updates the genesis block in db.
@@ -235,12 +252,50 @@ return params.AllEthashProtocolChanges, common.Hash{}, errGenesisNoConfig
}
applyOverrides := func(config *params.ChainConfig) {
if config != nil {
+ // If applying the superchain-registry to a known OP-Stack chain,
+ // then override the local chain-config with that from the registry.
+ if overrides != nil && overrides.ApplySuperchainUpgrades && config.IsOptimism() && config.ChainID != nil && config.ChainID.IsUint64() {
+ if _, ok := superchain.OPChains[config.ChainID.Uint64()]; ok {
+ conf, err := params.LoadOPStackChainConfig(config.ChainID.Uint64())
+ if err != nil {
+ log.Warn("failed to load chain config from superchain-registry, skipping override", "err", err, "chain_id", config.ChainID)
+ } else {
+ *config = *conf
+ }
+ }
+ }
+
+ if config.IsOptimism() && config.ChainID != nil && config.ChainID.Cmp(big.NewInt(params.OPGoerliChainID)) == 0 {
+ // Apply Optimism Goerli regolith time
+ config.RegolithTime = ¶ms.OptimismGoerliRegolithTime
+ }
+ if config.IsOptimism() && config.ChainID != nil && config.ChainID.Cmp(big.NewInt(params.BaseGoerliChainID)) == 0 {
+ // Apply Base Goerli regolith time
+ config.RegolithTime = ¶ms.BaseGoerliRegolithTime
+ }
if overrides != nil && overrides.OverrideCancun != nil {
config.CancunTime = overrides.OverrideCancun
}
if overrides != nil && overrides.OverrideVerkle != nil {
config.VerkleTime = overrides.OverrideVerkle
}
+ if overrides != nil && overrides.OverrideOptimismCanyon != nil {
+ config.CanyonTime = overrides.OverrideOptimismCanyon
+ config.ShanghaiTime = overrides.OverrideOptimismCanyon
+ if config.Optimism != nil && config.Optimism.EIP1559DenominatorCanyon == 0 {
+ config.Optimism.EIP1559DenominatorCanyon = 250
+ }
+ }
+ if overrides != nil && overrides.OverrideOptimismEcotone != nil {
+ config.EcotoneTime = overrides.OverrideOptimismEcotone
+ config.CancunTime = overrides.OverrideOptimismEcotone
+ }
+ if overrides != nil && overrides.OverrideOptimismFjord != nil {
+ config.FjordTime = overrides.OverrideOptimismFjord
+ }
+ if overrides != nil && overrides.OverrideOptimismInterop != nil {
+ config.InteropTime = overrides.OverrideOptimismInterop
+ }
}
}
// Just commit the new block if there is no stored genesis block.
@@ -263,8 +318,13 @@ // The genesis block is present(perhaps in ancient database) while the
// state database is not initialized yet. It can happen that the node
// is initialized with an external ancient store. Commit genesis state
// in this case.
+ // If the bedrock block is not 0, that implies that the network was migrated at the bedrock block.
+ // In this case the genesis state may not be in the state database (e.g. op-geth is performing a snap
+ // sync without an existing datadir) & even if it were, would not be useful as op-geth is not able to
+ // execute the pre-bedrock STF.
header := rawdb.ReadHeader(db, stored, 0)
- if header.Root != types.EmptyRootHash && !triedb.Initialized(header.Root) {
+ transitionedNetwork := genesis != nil && genesis.Config != nil && genesis.Config.BedrockBlock != nil && genesis.Config.BedrockBlock.Uint64() != 0
+ if header.Root != types.EmptyRootHash && !triedb.Initialized(header.Root) && !transitionedNetwork {
if genesis == nil {
genesis = DefaultGenesisBlock()
}
@@ -385,8 +445,15 @@ }
// ToBlock returns the genesis block according to genesis specification.
func (g *Genesis) ToBlock() *types.Block {
- root, err := hashAlloc(&g.Alloc, g.IsVerkle())
- if err != nil {
+ var root common.Hash
+ var err error
+ if g.StateHash != nil {
+ if len(g.Alloc) > 0 {
+ panic(fmt.Errorf("cannot both have genesis hash %s "+
+ "and non-empty state-allocation", *g.StateHash))
+ }
+ root = *g.StateHash
+ } else if root, err = hashAlloc(&g.Alloc, g.IsVerkle()); err != nil {
panic(err)
}
head := &types.Header{
diff --git go-ethereum/params/config.go op-geth/params/config.go
index 21ede457fd6820869a935c8b195473519073a58d..bbd3ad76c380b6a0e90c0861287ad8ece1b7fa97 100644
--- go-ethereum/params/config.go
+++ op-geth/params/config.go
@@ -20,8 +20,8 @@ import (
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/params/forks"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/params/forks"
)
// Genesis hashes to enforce below configs on.
@@ -30,6 +30,32 @@ MainnetGenesisHash = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3")
HoleskyGenesisHash = common.HexToHash("0xb5f7f912443c940f21fd611f12828d75b534364ed9e95ca4e307729a4661bde4")
SepoliaGenesisHash = common.HexToHash("0x25a5cc106eea7138acab33231d7160d69cb777ee0c2c553fcddf5138993e6dd9")
GoerliGenesisHash = common.HexToHash("0xbf7e331f7f7c1dd2e05159666b3bf8bc7a8a3a9eb1d518969eab529dd9b88c1a")
+)
+
+const (
+ OPMainnetChainID = 10
+ OPGoerliChainID = 420
+ BaseMainnetChainID = 8453
+ BaseGoerliChainID = 84531
+ baseSepoliaChainID = 84532
+ baseGoerliDevnetChainID = 11763071
+ pgnSepoliaChainID = 58008
+ devnetChainID = 997
+ chaosnetChainID = 888
+)
+
+// OP Stack chain config
+var (
+ // March 17, 2023 @ 7:00:00 pm UTC
+ OptimismGoerliRegolithTime = uint64(1679079600)
+ // May 4, 2023 @ 5:00:00 pm UTC
+ BaseGoerliRegolithTime = uint64(1683219600)
+ // Apr 21, 2023 @ 6:30:00 pm UTC
+ baseGoerliDevnetRegolithTime = uint64(1682101800)
+ // March 5, 2023 @ 2:48:00 am UTC
+ devnetRegolithTime = uint64(1677984480)
+ // August 16, 2023 @ 3:34:22 am UTC
+ chaosnetRegolithTime = uint64(1692156862)
)
func newUint64(val uint64) *uint64 { return &val }
@@ -307,6 +333,16 @@ Ethash: new(EthashConfig),
Clique: nil,
}
TestRules = TestChainConfig.Rules(new(big.Int), false, 0)
+
+ // This is an Optimism chain config with bedrock starting a block 5, introduced for historical endpoint testing, largely based on the clique config
+ OptimismTestConfig = func() *ChainConfig {
+ conf := *AllCliqueProtocolChanges // copy the config
+ conf.Clique = nil
+ conf.TerminalTotalDifficultyPassed = true
+ conf.BedrockBlock = big.NewInt(5)
+ conf.Optimism = &OptimismConfig{EIP1559Elasticity: 50, EIP1559Denominator: 10}
+ return &conf
+ }()
)
// NetworkNames are user friendly names to use in the chain spec banner.
@@ -353,6 +389,15 @@ CancunTime *uint64 `json:"cancunTime,omitempty"` // Cancun switch time (nil = no fork, 0 = already on cancun)
PragueTime *uint64 `json:"pragueTime,omitempty"` // Prague switch time (nil = no fork, 0 = already on prague)
VerkleTime *uint64 `json:"verkleTime,omitempty"` // Verkle switch time (nil = no fork, 0 = already on verkle)
+ BedrockBlock *big.Int `json:"bedrockBlock,omitempty"` // Bedrock switch block (nil = no fork, 0 = already on optimism bedrock)
+ RegolithTime *uint64 `json:"regolithTime,omitempty"` // Regolith switch time (nil = no fork, 0 = already on optimism regolith)
+ CanyonTime *uint64 `json:"canyonTime,omitempty"` // Canyon switch time (nil = no fork, 0 = already on optimism canyon)
+ // Delta: the Delta upgrade does not affect the execution-layer, and is thus not configurable in the chain config.
+ EcotoneTime *uint64 `json:"ecotoneTime,omitempty"` // Ecotone switch time (nil = no fork, 0 = already on optimism ecotone)
+ FjordTime *uint64 `json:"fjordTime,omitempty"` // Fjord switch time (nil = no fork, 0 = already on Optimism Fjord)
+
+ InteropTime *uint64 `json:"interopTime,omitempty"` // Interop switch time (nil = no fork, 0 = already on optimism interop)
+
// TerminalTotalDifficulty is the amount of total difficulty reached by
// the network that triggers the consensus upgrade.
TerminalTotalDifficulty *big.Int `json:"terminalTotalDifficulty,omitempty"`
@@ -365,6 +410,9 @@
// Various consensus engines
Ethash *EthashConfig `json:"ethash,omitempty"`
Clique *CliqueConfig `json:"clique,omitempty"`
+
+ // Optimism config, nil if not active
+ Optimism *OptimismConfig `json:"optimism,omitempty"`
}
// EthashConfig is the consensus engine configs for proof-of-work based sealing.
@@ -386,6 +434,18 @@ func (c *CliqueConfig) String() string {
return "clique"
}
+// OptimismConfig is the optimism config.
+type OptimismConfig struct {
+ EIP1559Elasticity uint64 `json:"eip1559Elasticity"`
+ EIP1559Denominator uint64 `json:"eip1559Denominator"`
+ EIP1559DenominatorCanyon uint64 `json:"eip1559DenominatorCanyon"`
+}
+
+// String implements the stringer interface, returning the optimism fee config details.
+func (o *OptimismConfig) String() string {
+ return "optimism"
+}
+
// Description returns a human-readable description of ChainConfig.
func (c *ChainConfig) Description() string {
var banner string
@@ -397,6 +457,8 @@ network = "unknown"
}
banner += fmt.Sprintf("Chain ID: %v (%s)\n", c.ChainID, network)
switch {
+ case c.Optimism != nil:
+ banner += "Consensus: Optimism\n"
case c.Ethash != nil:
if c.TerminalTotalDifficulty == nil {
banner += "Consensus: Ethash (proof-of-work)\n"
@@ -475,6 +537,21 @@ }
if c.VerkleTime != nil {
banner += fmt.Sprintf(" - Verkle: @%-10v\n", *c.VerkleTime)
}
+ if c.RegolithTime != nil {
+ banner += fmt.Sprintf(" - Regolith: @%-10v\n", *c.RegolithTime)
+ }
+ if c.CanyonTime != nil {
+ banner += fmt.Sprintf(" - Canyon: @%-10v\n", *c.CanyonTime)
+ }
+ if c.EcotoneTime != nil {
+ banner += fmt.Sprintf(" - Ecotone: @%-10v\n", *c.EcotoneTime)
+ }
+ if c.FjordTime != nil {
+ banner += fmt.Sprintf(" - Fjord: @%-10v\n", *c.FjordTime)
+ }
+ if c.InteropTime != nil {
+ banner += fmt.Sprintf(" - Interop: @%-10v\n", *c.InteropTime)
+ }
return banner
}
@@ -578,6 +655,62 @@ func (c *ChainConfig) IsVerkle(num *big.Int, time uint64) bool {
return c.IsLondon(num) && isTimestampForked(c.VerkleTime, time)
}
+// IsBedrock returns whether num is either equal to the Bedrock fork block or greater.
+func (c *ChainConfig) IsBedrock(num *big.Int) bool {
+ return isBlockForked(c.BedrockBlock, num)
+}
+
+func (c *ChainConfig) IsRegolith(time uint64) bool {
+ return isTimestampForked(c.RegolithTime, time)
+}
+
+func (c *ChainConfig) IsCanyon(time uint64) bool {
+ return isTimestampForked(c.CanyonTime, time)
+}
+
+func (c *ChainConfig) IsEcotone(time uint64) bool {
+ return isTimestampForked(c.EcotoneTime, time)
+}
+
+func (c *ChainConfig) IsFjord(time uint64) bool {
+ return isTimestampForked(c.FjordTime, time)
+}
+
+func (c *ChainConfig) IsInterop(time uint64) bool {
+ return isTimestampForked(c.InteropTime, time)
+}
+
+// IsOptimism returns whether the node is an optimism node or not.
+func (c *ChainConfig) IsOptimism() bool {
+ return c.Optimism != nil
+}
+
+// IsOptimismBedrock returns true iff this is an optimism node & bedrock is active
+func (c *ChainConfig) IsOptimismBedrock(num *big.Int) bool {
+ return c.IsOptimism() && c.IsBedrock(num)
+}
+
+func (c *ChainConfig) IsOptimismRegolith(time uint64) bool {
+ return c.IsOptimism() && c.IsRegolith(time)
+}
+
+func (c *ChainConfig) IsOptimismCanyon(time uint64) bool {
+ return c.IsOptimism() && c.IsCanyon(time)
+}
+
+func (c *ChainConfig) IsOptimismEcotone(time uint64) bool {
+ return c.IsOptimism() && c.IsEcotone(time)
+}
+
+func (c *ChainConfig) IsOptimismFjord(time uint64) bool {
+ return c.IsOptimism() && c.IsFjord(time)
+}
+
+// IsOptimismPreBedrock returns true iff this is an optimism node & bedrock is not yet active
+func (c *ChainConfig) IsOptimismPreBedrock(num *big.Int) bool {
+ return c.IsOptimism() && !c.IsBedrock(num)
+}
+
// CheckCompatible checks whether scheduled fork transitions have been imported
// with a mismatching chain configuration.
func (c *ChainConfig) CheckCompatible(newcfg *ChainConfig, height uint64, time uint64) *ConfigCompatError {
@@ -743,12 +876,22 @@ return nil
}
// BaseFeeChangeDenominator bounds the amount the base fee can change between blocks.
-func (c *ChainConfig) BaseFeeChangeDenominator() uint64 {
+// The time parameters is the timestamp of the block to determine if Canyon is active or not
+func (c *ChainConfig) BaseFeeChangeDenominator(time uint64) uint64 {
+ if c.Optimism != nil {
+ if c.IsCanyon(time) {
+ return c.Optimism.EIP1559DenominatorCanyon
+ }
+ return c.Optimism.EIP1559Denominator
+ }
return DefaultBaseFeeChangeDenominator
}
// ElasticityMultiplier bounds the maximum gas limit an EIP-1559 block may have.
func (c *ChainConfig) ElasticityMultiplier() uint64 {
+ if c.Optimism != nil {
+ return c.Optimism.EIP1559Elasticity
+ }
return DefaultElasticityMultiplier
}
@@ -902,6 +1045,8 @@ IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul bool
IsBerlin, IsLondon bool
IsMerge, IsShanghai, IsCancun, IsPrague bool
IsVerkle bool
+ IsOptimismBedrock, IsOptimismRegolith bool
+ IsOptimismCanyon, IsOptimismFjord bool
}
// Rules ensures c's ChainID is not nil.
@@ -929,5 +1074,10 @@ IsShanghai: isMerge && c.IsShanghai(num, timestamp),
IsCancun: isMerge && c.IsCancun(num, timestamp),
IsPrague: isMerge && c.IsPrague(num, timestamp),
IsVerkle: isMerge && c.IsVerkle(num, timestamp),
+ // Optimism
+ IsOptimismBedrock: isMerge && c.IsOptimismBedrock(num),
+ IsOptimismRegolith: isMerge && c.IsOptimismRegolith(timestamp),
+ IsOptimismCanyon: isMerge && c.IsOptimismCanyon(timestamp),
+ IsOptimismFjord: isMerge && c.IsOptimismFjord(timestamp),
}
}
diff --git go-ethereum/params/protocol_params.go op-geth/params/protocol_params.go
index 7eb63e89ac619c28b9f96bdf7617aa0a2d0fe504..b4b7a10503d87cb4f55dde8cc4440fbbd399ff62 100644
--- go-ethereum/params/protocol_params.go
+++ op-geth/params/protocol_params.go
@@ -19,7 +19,14 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
+)
+
+var (
+ // The base fee portion of the transaction fee accumulates at this predeploy
+ OptimismBaseFeeRecipient = common.HexToAddress("0x4200000000000000000000000000000000000019")
+ // The L1 portion of the transaction fee accumulates at this predeploy
+ OptimismL1FeeRecipient = common.HexToAddress("0x420000000000000000000000000000000000001A")
)
const (
@@ -158,6 +165,8 @@ Bls12381PairingBaseGas uint64 = 115000 // Base gas price for BLS12-381 elliptic curve pairing check
Bls12381PairingPerPairGas uint64 = 23000 // Per-point pair gas price for BLS12-381 elliptic curve pairing check
Bls12381MapG1Gas uint64 = 5500 // Gas price for BLS12-381 mapping field element to G1 operation
Bls12381MapG2Gas uint64 = 110000 // Gas price for BLS12-381 mapping field element to G2 operation
+
+ P256VerifyGas uint64 = 3450 // secp256r1 elliptic curve signature verifier gas price
// The Refund Quotient is the cap on how much of the used gas can be refunded. Before EIP-3529,
// up to half the consumed gas could be refunded. Redefined as 1/5th in EIP-3529
Chain config cleanup
+8
-5
The optimism Goerli testnet used clique-config data to make geth internals accept blocks. Post-bedrock the beacon-consensus (i.e. follow Engine API) is now used, and the clique config is removed.
diff --git go-ethereum/core/rawdb/accessors_metadata.go op-geth/core/rawdb/accessors_metadata.go
index 859566f722f5960b0ce417514d6f20ff35a5cbe9..a62b198500bc0190f530450ab2bf9793fc27f33f 100644
--- go-ethereum/core/rawdb/accessors_metadata.go
+++ op-geth/core/rawdb/accessors_metadata.go
@@ -20,11 +20,11 @@ import (
"encoding/json"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
// ReadDatabaseVersion retrieves the version number of the database.
@@ -63,6 +63,9 @@ var config params.ChainConfig
if err := json.Unmarshal(data, &config); err != nil {
log.Error("Invalid chain config JSON", "hash", hash, "err", err)
return nil
+ }
+ if config.Optimism != nil {
+ config.Clique = nil // get rid of legacy clique data in chain config (optimism goerli issue)
}
return &config
}
Genesis loading
+26
-20
diff --git go-ethereum/core/gen_genesis.go op-geth/core/gen_genesis.go
index b8acf9df7c91cc03c8cfda2fcba226b4f8d365be..00e44bf900d4f3547c471bc799394b68d4e7f1b8 100644
--- go-ethereum/core/gen_genesis.go
+++ op-geth/core/gen_genesis.go
@@ -7,11 +7,11 @@ "encoding/json"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
var _ = (*genesisSpecMarshaling)(nil)
@@ -34,6 +34,7 @@ ParentHash common.Hash `json:"parentHash"`
BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"`
ExcessBlobGas *math.HexOrDecimal64 `json:"excessBlobGas"`
BlobGasUsed *math.HexOrDecimal64 `json:"blobGasUsed"`
+ StateHash *common.Hash `json:"stateHash,omitempty"`
}
var enc Genesis
enc.Config = g.Config
@@ -56,27 +57,29 @@ enc.ParentHash = g.ParentHash
enc.BaseFee = (*math.HexOrDecimal256)(g.BaseFee)
enc.ExcessBlobGas = (*math.HexOrDecimal64)(g.ExcessBlobGas)
enc.BlobGasUsed = (*math.HexOrDecimal64)(g.BlobGasUsed)
+ enc.StateHash = g.StateHash
return json.Marshal(&enc)
}
// UnmarshalJSON unmarshals from JSON.
func (g *Genesis) UnmarshalJSON(input []byte) error {
type Genesis struct {
- Config *params.ChainConfig `json:"config"`
- Nonce *math.HexOrDecimal64 `json:"nonce"`
- Timestamp *math.HexOrDecimal64 `json:"timestamp"`
- ExtraData *hexutil.Bytes `json:"extraData"`
- GasLimit *math.HexOrDecimal64 `json:"gasLimit" gencodec:"required"`
- Difficulty *math.HexOrDecimal256 `json:"difficulty" gencodec:"required"`
- Mixhash *common.Hash `json:"mixHash"`
- Coinbase *common.Address `json:"coinbase"`
- Alloc map[common.UnprefixedAddress]types.Account `json:"alloc" gencodec:"required"`
- Number *math.HexOrDecimal64 `json:"number"`
- GasUsed *math.HexOrDecimal64 `json:"gasUsed"`
- ParentHash *common.Hash `json:"parentHash"`
- BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"`
- ExcessBlobGas *math.HexOrDecimal64 `json:"excessBlobGas"`
- BlobGasUsed *math.HexOrDecimal64 `json:"blobGasUsed"`
+ Config *params.ChainConfig `json:"config"`
+ Nonce *math.HexOrDecimal64 `json:"nonce"`
+ Timestamp *math.HexOrDecimal64 `json:"timestamp"`
+ ExtraData *hexutil.Bytes `json:"extraData"`
+ GasLimit *math.HexOrDecimal64 `json:"gasLimit" gencodec:"required"`
+ Difficulty *math.HexOrDecimal256 `json:"difficulty" gencodec:"required"`
+ Mixhash *common.Hash `json:"mixHash"`
+ Coinbase *common.Address `json:"coinbase"`
+ Alloc map[common.UnprefixedAddress]GenesisAccount `json:"alloc" gencodec:"required"`
+ Number *math.HexOrDecimal64 `json:"number"`
+ GasUsed *math.HexOrDecimal64 `json:"gasUsed"`
+ ParentHash *common.Hash `json:"parentHash"`
+ BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"`
+ ExcessBlobGas *math.HexOrDecimal64 `json:"excessBlobGas"`
+ BlobGasUsed *math.HexOrDecimal64 `json:"blobGasUsed"`
+ StateHash *common.Hash `json:"stateHash,omitempty"`
}
var dec Genesis
if err := json.Unmarshal(input, &dec); err != nil {
@@ -132,6 +135,9 @@ g.ExcessBlobGas = (*uint64)(dec.ExcessBlobGas)
}
if dec.BlobGasUsed != nil {
g.BlobGasUsed = (*uint64)(dec.BlobGasUsed)
+ }
+ if dec.StateHash != nil {
+ g.StateHash = dec.StateHash
}
return nil
}
Superchain config
+379
-0
Testing of the superchain configuration
diff --git go-ethereum/core/superchain.go op-geth/core/superchain.go
new file mode 100644
index 0000000000000000000000000000000000000000..7a005fddfe89bd6fe87b8d15a3f432339197f4aa
--- /dev/null
+++ op-geth/core/superchain.go
@@ -0,0 +1,101 @@
+package core
+
+import (
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum-optimism/superchain-registry/superchain"
+
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/params"
+)
+
+func LoadOPStackGenesis(chainID uint64) (*Genesis, error) {
+ chConfig, ok := superchain.OPChains[chainID]
+ if !ok {
+ return nil, fmt.Errorf("unknown chain ID: %d", chainID)
+ }
+
+ cfg, err := params.LoadOPStackChainConfig(chainID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to load params.ChainConfig for chain %d: %w", chainID, err)
+ }
+
+ gen, err := superchain.LoadGenesis(chainID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to load genesis definition for chain %d: %w", chainID, err)
+ }
+
+ genesis := &Genesis{
+ Config: cfg,
+ Nonce: gen.Nonce,
+ Timestamp: gen.Timestamp,
+ ExtraData: gen.ExtraData,
+ GasLimit: gen.GasLimit,
+ Difficulty: (*big.Int)(gen.Difficulty),
+ Mixhash: common.Hash(gen.Mixhash),
+ Coinbase: common.Address(gen.Coinbase),
+ Alloc: make(GenesisAlloc),
+ Number: gen.Number,
+ GasUsed: gen.GasUsed,
+ ParentHash: common.Hash(gen.ParentHash),
+ BaseFee: (*big.Int)(gen.BaseFee),
+ ExcessBlobGas: gen.ExcessBlobGas,
+ BlobGasUsed: gen.BlobGasUsed,
+ }
+
+ for addr, acc := range gen.Alloc {
+ var code []byte
+ if acc.CodeHash != ([32]byte{}) {
+ dat, err := superchain.LoadContractBytecode(acc.CodeHash)
+ if err != nil {
+ return nil, fmt.Errorf("failed to load bytecode %s of address %s in chain %d: %w", acc.CodeHash, addr, chainID, err)
+ }
+ code = dat
+ }
+ var storage map[common.Hash]common.Hash
+ if len(acc.Storage) > 0 {
+ storage = make(map[common.Hash]common.Hash)
+ for k, v := range acc.Storage {
+ storage[common.Hash(k)] = common.Hash(v)
+ }
+ }
+ bal := common.Big0
+ if acc.Balance != nil {
+ bal = (*big.Int)(acc.Balance)
+ }
+ genesis.Alloc[common.Address(addr)] = GenesisAccount{
+ Code: code,
+ Storage: storage,
+ Balance: bal,
+ Nonce: acc.Nonce,
+ }
+ }
+ if gen.StateHash != nil {
+ if len(gen.Alloc) > 0 {
+ return nil, fmt.Errorf("chain definition unexpectedly contains both allocation (%d) and state-hash %s", len(gen.Alloc), *gen.StateHash)
+ }
+ genesis.StateHash = (*common.Hash)(gen.StateHash)
+ }
+
+ genesisBlock := genesis.ToBlock()
+ genesisBlockHash := genesisBlock.Hash()
+ expectedHash := common.Hash([32]byte(chConfig.Genesis.L2.Hash))
+
+ // Verify we correctly produced the genesis config by recomputing the genesis-block-hash,
+ // and check the genesis matches the chain genesis definition.
+ if chConfig.Genesis.L2.Number != genesisBlock.NumberU64() {
+ switch chainID {
+ case params.OPMainnetChainID:
+ expectedHash = common.HexToHash("0x7ca38a1916c42007829c55e69d3e9a73265554b586a499015373241b8a3fa48b")
+ case params.OPGoerliChainID:
+ expectedHash = common.HexToHash("0xc1fc15cd51159b1f1e5cbc4b82e85c1447ddfa33c52cf1d98d14fba0d6354be1")
+ default:
+ return nil, fmt.Errorf("unknown stateless genesis definition for chain %d", chainID)
+ }
+ }
+ if expectedHash != genesisBlockHash {
+ return nil, fmt.Errorf("chainID=%d: produced genesis with hash %s but expected %s", chainID, genesisBlockHash, expectedHash)
+ }
+ return genesis, nil
+}
diff --git go-ethereum/params/superchain.go op-geth/params/superchain.go
new file mode 100644
index 0000000000000000000000000000000000000000..f4383ecdff9bcc0f5312adcf1a9e8d5acc44578f
--- /dev/null
+++ op-geth/params/superchain.go
@@ -0,0 +1,278 @@
+package params
+
+import (
+ "encoding/binary"
+ "fmt"
+ "math/big"
+ "sort"
+ "strings"
+
+ "github.com/ethereum-optimism/superchain-registry/superchain"
+ "github.com/tenderly/op-geth/common"
+)
+
+var OPStackSupport = ProtocolVersionV0{Build: [8]byte{}, Major: 6, Minor: 0, Patch: 0, PreRelease: 0}.Encode()
+
+func init() {
+ for id, ch := range superchain.OPChains {
+ NetworkNames[fmt.Sprintf("%d", id)] = ch.Name
+ }
+}
+
+func OPStackChainIDByName(name string) (uint64, error) {
+ for id, ch := range superchain.OPChains {
+ if ch.Chain+"-"+ch.Superchain == name {
+ return id, nil
+ }
+ }
+ return 0, fmt.Errorf("unknown chain %q", name)
+}
+
+func OPStackChainNames() (out []string) {
+ for _, ch := range superchain.OPChains {
+ out = append(out, ch.Chain+"-"+ch.Superchain)
+ }
+ sort.Strings(out)
+ return
+}
+
+func LoadOPStackChainConfig(chainID uint64) (*ChainConfig, error) {
+ chConfig, ok := superchain.OPChains[chainID]
+ if !ok {
+ return nil, fmt.Errorf("unknown chain ID: %d", chainID)
+ }
+
+ genesisActivation := uint64(0)
+ out := &ChainConfig{
+ ChainID: new(big.Int).SetUint64(chainID),
+ HomesteadBlock: common.Big0,
+ DAOForkBlock: nil,
+ DAOForkSupport: false,
+ EIP150Block: common.Big0,
+ EIP155Block: common.Big0,
+ EIP158Block: common.Big0,
+ ByzantiumBlock: common.Big0,
+ ConstantinopleBlock: common.Big0,
+ PetersburgBlock: common.Big0,
+ IstanbulBlock: common.Big0,
+ MuirGlacierBlock: common.Big0,
+ BerlinBlock: common.Big0,
+ LondonBlock: common.Big0,
+ ArrowGlacierBlock: common.Big0,
+ GrayGlacierBlock: common.Big0,
+ MergeNetsplitBlock: common.Big0,
+ ShanghaiTime: chConfig.CanyonTime, // Shanghai activates with Canyon
+ CancunTime: chConfig.EcotoneTime, // Cancun activates with Ecotone
+ PragueTime: nil,
+ BedrockBlock: common.Big0,
+ RegolithTime: &genesisActivation,
+ CanyonTime: chConfig.CanyonTime,
+ EcotoneTime: chConfig.EcotoneTime,
+ FjordTime: chConfig.FjordTime,
+ TerminalTotalDifficulty: common.Big0,
+ TerminalTotalDifficultyPassed: true,
+ Ethash: nil,
+ Clique: nil,
+ Optimism: &OptimismConfig{
+ EIP1559Elasticity: 6,
+ EIP1559Denominator: 50,
+ EIP1559DenominatorCanyon: 250,
+ },
+ }
+
+ // special overrides for OP-Stack chains with pre-Regolith upgrade history
+ switch chainID {
+ case OPGoerliChainID:
+ out.LondonBlock = big.NewInt(4061224)
+ out.ArrowGlacierBlock = big.NewInt(4061224)
+ out.GrayGlacierBlock = big.NewInt(4061224)
+ out.MergeNetsplitBlock = big.NewInt(4061224)
+ out.BedrockBlock = big.NewInt(4061224)
+ out.RegolithTime = &OptimismGoerliRegolithTime
+ out.Optimism.EIP1559Elasticity = 10
+ case OPMainnetChainID:
+ out.BerlinBlock = big.NewInt(3950000)
+ out.LondonBlock = big.NewInt(105235063)
+ out.ArrowGlacierBlock = big.NewInt(105235063)
+ out.GrayGlacierBlock = big.NewInt(105235063)
+ out.MergeNetsplitBlock = big.NewInt(105235063)
+ out.BedrockBlock = big.NewInt(105235063)
+ case BaseGoerliChainID:
+ out.RegolithTime = &BaseGoerliRegolithTime
+ out.Optimism.EIP1559Elasticity = 10
+ case baseSepoliaChainID:
+ out.Optimism.EIP1559Elasticity = 10
+ case baseGoerliDevnetChainID:
+ out.RegolithTime = &baseGoerliDevnetRegolithTime
+ case pgnSepoliaChainID:
+ out.Optimism.EIP1559Elasticity = 2
+ out.Optimism.EIP1559Denominator = 8
+ case devnetChainID:
+ out.RegolithTime = &devnetRegolithTime
+ out.Optimism.EIP1559Elasticity = 10
+ case chaosnetChainID:
+ out.RegolithTime = &chaosnetRegolithTime
+ out.Optimism.EIP1559Elasticity = 10
+ }
+
+ return out, nil
+}
+
+// ProtocolVersion encodes the OP-Stack protocol version. See OP-Stack superchain-upgrade specification.
+type ProtocolVersion [32]byte
+
+func (p ProtocolVersion) MarshalText() ([]byte, error) {
+ return common.Hash(p).MarshalText()
+}
+
+func (p *ProtocolVersion) UnmarshalText(input []byte) error {
+ return (*common.Hash)(p).UnmarshalText(input)
+}
+
+func (p ProtocolVersion) Parse() (versionType uint8, build [8]byte, major, minor, patch, preRelease uint32) {
+ versionType = p[0]
+ if versionType != 0 {
+ return
+ }
+ // bytes 1:8 reserved for future use
+ copy(build[:], p[8:16]) // differentiates forks and custom-builds of standard protocol
+ major = binary.BigEndian.Uint32(p[16:20]) // incompatible API changes
+ minor = binary.BigEndian.Uint32(p[20:24]) // identifies additional functionality in backwards compatible manner
+ patch = binary.BigEndian.Uint32(p[24:28]) // identifies backward-compatible bug-fixes
+ preRelease = binary.BigEndian.Uint32(p[28:32]) // identifies unstable versions that may not satisfy the above
+ return
+}
+
+func (p ProtocolVersion) String() string {
+ versionType, build, major, minor, patch, preRelease := p.Parse()
+ if versionType != 0 {
+ return "v0.0.0-unknown." + common.Hash(p).String()
+ }
+ ver := fmt.Sprintf("v%d.%d.%d", major, minor, patch)
+ if preRelease != 0 {
+ ver += fmt.Sprintf("-%d", preRelease)
+ }
+ if build != ([8]byte{}) {
+ if humanBuildTag(build) {
+ ver += fmt.Sprintf("+%s", strings.TrimRight(string(build[:]), "\x00"))
+ } else {
+ ver += fmt.Sprintf("+0x%x", build)
+ }
+ }
+ return ver
+}
+
+// humanBuildTag identifies which build tag we can stringify for human-readable versions
+func humanBuildTag(v [8]byte) bool {
+ for i, c := range v { // following semver.org advertised regex, alphanumeric with '-' and '.', except leading '.'.
+ if c == 0 { // trailing zeroed are allowed
+ for _, d := range v[i:] {
+ if d != 0 {
+ return false
+ }
+ }
+ return true
+ }
+ if !((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-' || (c == '.' && i > 0)) {
+ return false
+ }
+ }
+ return true
+}
+
+// ProtocolVersionComparison is used to identify how far ahead/outdated a protocol version is relative to another.
+// This value is used in metrics and switch comparisons, to easily identify each type of version difference.
+// Negative values mean the version is outdated.
+// Positive values mean the version is up-to-date.
+// Matching versions have a 0.
+type ProtocolVersionComparison int
+
+const (
+ AheadMajor ProtocolVersionComparison = 4
+ OutdatedMajor ProtocolVersionComparison = -4
+ AheadMinor ProtocolVersionComparison = 3
+ OutdatedMinor ProtocolVersionComparison = -3
+ AheadPatch ProtocolVersionComparison = 2
+ OutdatedPatch ProtocolVersionComparison = -2
+ AheadPrerelease ProtocolVersionComparison = 1
+ OutdatedPrerelease ProtocolVersionComparison = -1
+ Matching ProtocolVersionComparison = 0
+ DiffVersionType ProtocolVersionComparison = 100
+ DiffBuild ProtocolVersionComparison = 101
+ EmptyVersion ProtocolVersionComparison = 102
+ InvalidVersion ProtocolVersionComparison = 103
+)
+
+func (p ProtocolVersion) Compare(other ProtocolVersion) (cmp ProtocolVersionComparison) {
+ if p == (ProtocolVersion{}) || (other == (ProtocolVersion{})) {
+ return EmptyVersion
+ }
+ aVersionType, aBuild, aMajor, aMinor, aPatch, aPreRelease := p.Parse()
+ bVersionType, bBuild, bMajor, bMinor, bPatch, bPreRelease := other.Parse()
+ if aVersionType != bVersionType {
+ return DiffVersionType
+ }
+ if aBuild != bBuild {
+ return DiffBuild
+ }
+ // max values are reserved, consider versions with these values invalid
+ if aMajor == ^uint32(0) || aMinor == ^uint32(0) || aPatch == ^uint32(0) || aPreRelease == ^uint32(0) ||
+ bMajor == ^uint32(0) || bMinor == ^uint32(0) || bPatch == ^uint32(0) || bPreRelease == ^uint32(0) {
+ return InvalidVersion
+ }
+ fn := func(a, b uint32, ahead, outdated ProtocolVersionComparison) ProtocolVersionComparison {
+ if a == b {
+ return Matching
+ }
+ if a > b {
+ return ahead
+ }
+ return outdated
+ }
+ if aPreRelease != 0 { // if A is a pre-release, then decrement the version before comparison
+ if aPatch != 0 {
+ aPatch -= 1
+ } else if aMinor != 0 {
+ aMinor -= 1
+ aPatch = ^uint32(0) // max value
+ } else if aMajor != 0 {
+ aMajor -= 1
+ aMinor = ^uint32(0) // max value
+ }
+ }
+ if bPreRelease != 0 { // if B is a pre-release, then decrement the version before comparison
+ if bPatch != 0 {
+ bPatch -= 1
+ } else if bMinor != 0 {
+ bMinor -= 1
+ bPatch = ^uint32(0) // max value
+ } else if bMajor != 0 {
+ bMajor -= 1
+ bMinor = ^uint32(0) // max value
+ }
+ }
+ if c := fn(aMajor, bMajor, AheadMajor, OutdatedMajor); c != Matching {
+ return c
+ }
+ if c := fn(aMinor, bMinor, AheadMinor, OutdatedMinor); c != Matching {
+ return c
+ }
+ if c := fn(aPatch, bPatch, AheadPatch, OutdatedPatch); c != Matching {
+ return c
+ }
+ return fn(aPreRelease, bPreRelease, AheadPrerelease, OutdatedPrerelease)
+}
+
+type ProtocolVersionV0 struct {
+ Build [8]byte
+ Major, Minor, Patch, PreRelease uint32
+}
+
+func (v ProtocolVersionV0) Encode() (out ProtocolVersion) {
+ copy(out[8:16], v.Build[:])
+ binary.BigEndian.PutUint32(out[16:20], v.Major)
+ binary.BigEndian.PutUint32(out[20:24], v.Minor)
+ binary.BigEndian.PutUint32(out[24:28], v.Patch)
+ binary.BigEndian.PutUint32(out[28:32], v.PreRelease)
+ return
+}
Node modifications
+909
-292
Changes to the node configuration and services.
CLI
+345
-93
Flags
+277
-76
Flag changes: - Transactions can be forwarded to an RPC for sequencing. - Historical calls can be forwarded to a legacy node. - The tx pool propagation can be enabled/disabled. - The Optimism bedrock fork activation can be changed for testing.
diff --git go-ethereum/cmd/geth/config.go op-geth/cmd/geth/config.go
index 5f52f1df54423289b352083d1fcd672296d79571..b9e42168b218c849f1a65787f0edaed54fe13cd0 100644
--- go-ethereum/cmd/geth/config.go
+++ op-geth/cmd/geth/config.go
@@ -26,24 +26,24 @@ "runtime"
"strings"
"unicode"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/external"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/accounts/scwallet"
- "github.com/ethereum/go-ethereum/accounts/usbwallet"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/eth/catalyst"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/internal/version"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/params"
"github.com/naoina/toml"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/external"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/accounts/scwallet"
+ "github.com/tenderly/op-geth/accounts/usbwallet"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/eth/catalyst"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/internal/version"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/params"
"github.com/urfave/cli/v2"
)
@@ -173,10 +173,32 @@ if ctx.IsSet(utils.OverrideCancun.Name) {
v := ctx.Uint64(utils.OverrideCancun.Name)
cfg.Eth.OverrideCancun = &v
}
+
+ if ctx.IsSet(utils.OverrideOptimismCanyon.Name) {
+ v := ctx.Uint64(utils.OverrideOptimismCanyon.Name)
+ cfg.Eth.OverrideOptimismCanyon = &v
+ }
+
+ if ctx.IsSet(utils.OverrideOptimismEcotone.Name) {
+ v := ctx.Uint64(utils.OverrideOptimismEcotone.Name)
+ cfg.Eth.OverrideOptimismEcotone = &v
+ }
+
+ if ctx.IsSet(utils.OverrideOptimismFjord.Name) {
+ v := ctx.Uint64(utils.OverrideOptimismFjord.Name)
+ cfg.Eth.OverrideOptimismFjord = &v
+ }
+
+ if ctx.IsSet(utils.OverrideOptimismInterop.Name) {
+ v := ctx.Uint64(utils.OverrideOptimismInterop.Name)
+ cfg.Eth.OverrideOptimismInterop = &v
+ }
+
if ctx.IsSet(utils.OverrideVerkle.Name) {
v := ctx.Uint64(utils.OverrideVerkle.Name)
cfg.Eth.OverrideVerkle = &v
}
+
backend, eth := utils.RegisterEthService(stack, &cfg.Eth)
// Create gauge with geth system and build information
diff --git go-ethereum/cmd/geth/main.go op-geth/cmd/geth/main.go
index 2f7d37fdd7e7b7a8d69f2a7be749bdd9d34a21bb..380728aab8dfe8c6a2759e760763b7ea317c83ab 100644
--- go-ethereum/cmd/geth/main.go
+++ op-geth/cmd/geth/main.go
@@ -25,25 +25,25 @@ "strconv"
"strings"
"time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/console/prompt"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/ethclient"
- "github.com/ethereum/go-ethereum/internal/debug"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/node"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/console/prompt"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/ethclient"
+ "github.com/tenderly/op-geth/internal/debug"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/node"
"go.uber.org/automaxprocs/maxprocs"
// Force-load the tracer engines to trigger registration
- _ "github.com/ethereum/go-ethereum/eth/tracers/js"
- _ "github.com/ethereum/go-ethereum/eth/tracers/native"
+ _ "github.com/tenderly/op-geth/eth/tracers/js"
+ _ "github.com/tenderly/op-geth/eth/tracers/native"
"github.com/urfave/cli/v2"
)
@@ -67,10 +67,15 @@ utils.USBFlag,
utils.SmartCardDaemonPathFlag,
utils.OverrideCancun,
utils.OverrideVerkle,
+ utils.OverrideOptimismCanyon,
+ utils.OverrideOptimismEcotone,
+ utils.OverrideOptimismFjord,
+ utils.OverrideOptimismInterop,
utils.EnablePersonal,
utils.TxPoolLocalsFlag,
utils.TxPoolNoLocalsFlag,
utils.TxPoolJournalFlag,
+ utils.TxPoolJournalRemotesFlag,
utils.TxPoolRejournalFlag,
utils.TxPoolPriceLimitFlag,
utils.TxPoolPriceBumpFlag,
@@ -118,6 +123,7 @@ utils.MaxPeersFlag,
utils.MaxPendingPeersFlag,
utils.MiningEnabledFlag,
utils.MinerGasLimitFlag,
+ utils.MinerEffectiveGasLimitFlag,
utils.MinerGasPriceFlag,
utils.MinerEtherbaseFlag,
utils.MinerExtraDataFlag,
@@ -143,6 +149,14 @@ utils.GpoBlocksFlag,
utils.GpoPercentileFlag,
utils.GpoMaxGasPriceFlag,
utils.GpoIgnoreGasPriceFlag,
+ utils.GpoMinSuggestedPriorityFeeFlag,
+ utils.RollupSequencerHTTPFlag,
+ utils.RollupHistoricalRPCFlag,
+ utils.RollupHistoricalRPCTimeoutFlag,
+ utils.RollupDisableTxPoolGossipFlag,
+ utils.RollupComputePendingBlock,
+ utils.RollupHaltOnIncompatibleProtocolVersionFlag,
+ utils.RollupSuperchainUpgradesFlag,
configFileFlag,
utils.LogDebugFlag,
utils.LogBacktraceAtFlag,
@@ -305,6 +319,9 @@ 5. Networking is disabled; there is no listen-address, the maximum number of peers is set
to 0, and discovery is disabled.
`)
+ case ctx.IsSet(utils.OPNetworkFlag.Name):
+ log.Info("Starting geth on an OP network...", "network", ctx.String(utils.OPNetworkFlag.Name))
+
case !ctx.IsSet(utils.NetworkIdFlag.Name):
log.Info("Starting Geth on Ethereum mainnet...")
}
@@ -316,7 +333,14 @@ !ctx.IsSet(utils.SepoliaFlag.Name) &&
!ctx.IsSet(utils.GoerliFlag.Name) &&
!ctx.IsSet(utils.DeveloperFlag.Name) {
// Nope, we're really on mainnet. Bump that cache up!
+ // Note: If we don't set the OPNetworkFlag and have already initialized the database, we may hit this case.
log.Info("Bumping default cache on mainnet", "provided", ctx.Int(utils.CacheFlag.Name), "updated", 4096)
+ ctx.Set(utils.CacheFlag.Name, strconv.Itoa(4096))
+ }
+ } else if ctx.String(utils.SyncModeFlag.Name) != "light" && !ctx.IsSet(utils.CacheFlag.Name) && ctx.IsSet(utils.OPNetworkFlag.Name) {
+ // We haven't set the cache, but may used the OP network flag we may be on an OP stack mainnet.
+ if strings.Contains(ctx.String(utils.OPNetworkFlag.Name), "mainnet") {
+ log.Info("Bumping default cache on mainnet", "provided", ctx.Int(utils.CacheFlag.Name), "updated", 4096, "network", ctx.String(utils.OPNetworkFlag.Name))
ctx.Set(utils.CacheFlag.Name, strconv.Itoa(4096))
}
}
diff --git go-ethereum/cmd/utils/flags.go op-geth/cmd/utils/flags.go
index b813e52970d82a99205240866c8d291044b18161..b01b8aaf34a2c761eb7bd75612318261010de936 100644
--- go-ethereum/cmd/utils/flags.go
+++ op-geth/cmd/utils/flags.go
@@ -34,46 +34,46 @@ "strconv"
"strings"
"time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/fdlimit"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/txpool/legacypool"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/catalyst"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/eth/filters"
- "github.com/ethereum/go-ethereum/eth/gasprice"
- "github.com/ethereum/go-ethereum/eth/tracers"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/ethdb/remotedb"
- "github.com/ethereum/go-ethereum/ethstats"
- "github.com/ethereum/go-ethereum/graphql"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/metrics/exp"
- "github.com/ethereum/go-ethereum/metrics/influxdb"
- "github.com/ethereum/go-ethereum/miner"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/nat"
- "github.com/ethereum/go-ethereum/p2p/netutil"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/hashdb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
pcsclite "github.com/gballet/go-libpcsclite"
gopsutil "github.com/shirou/gopsutil/mem"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/fdlimit"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/txpool/legacypool"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/catalyst"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/eth/filters"
+ "github.com/tenderly/op-geth/eth/gasprice"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/ethdb/remotedb"
+ "github.com/tenderly/op-geth/ethstats"
+ "github.com/tenderly/op-geth/graphql"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/metrics/exp"
+ "github.com/tenderly/op-geth/metrics/influxdb"
+ "github.com/tenderly/op-geth/miner"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/nat"
+ "github.com/tenderly/op-geth/p2p/netutil"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/hashdb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
"github.com/urfave/cli/v2"
)
@@ -155,6 +155,15 @@ Name: "holesky",
Usage: "Holesky network: pre-configured proof-of-stake test network",
Category: flags.EthCategory,
}
+
+ OPNetworkFlag = &cli.StringFlag{
+ Name: "op-network",
+ Aliases: []string{"beta.op-network"},
+ Usage: "Select a pre-configured OP-Stack network (warning: op-mainnet and op-goerli require special sync," +
+ " datadir is recommended), options: " + strings.Join(params.OPStackChainNames(), ", "),
+ Category: flags.EthCategory,
+ }
+
// Dev mode
DeveloperFlag = &cli.BoolFlag{
Name: "dev",
@@ -252,6 +261,26 @@ Name: "override.verkle",
Usage: "Manually specify the Verkle fork timestamp, overriding the bundled setting",
Category: flags.EthCategory,
}
+ OverrideOptimismCanyon = &cli.Uint64Flag{
+ Name: "override.canyon",
+ Usage: "Manually specify the Optimism Canyon fork timestamp, overriding the bundled setting",
+ Category: flags.EthCategory,
+ }
+ OverrideOptimismEcotone = &cli.Uint64Flag{
+ Name: "override.ecotone",
+ Usage: "Manually specify the Optimism Ecotone fork timestamp, overriding the bundled setting",
+ Category: flags.EthCategory,
+ }
+ OverrideOptimismFjord = &cli.Uint64Flag{
+ Name: "override.fjord",
+ Usage: "Manually specify the Optimism Fjord fork timestamp, overriding the bundled setting",
+ Category: flags.EthCategory,
+ }
+ OverrideOptimismInterop = &cli.Uint64Flag{
+ Name: "override.interop",
+ Usage: "Manually specify the Optimsim Interop feature-set fork timestamp, overriding the bundled setting",
+ Category: flags.EthCategory,
+ }
SyncModeFlag = &flags.TextMarshalerFlag{
Name: "syncmode",
Usage: `Blockchain sync mode ("snap" or "full")`,
@@ -296,6 +325,11 @@ TxPoolJournalFlag = &cli.StringFlag{
Name: "txpool.journal",
Usage: "Disk journal for local transaction to survive node restarts",
Value: ethconfig.Defaults.TxPool.Journal,
+ Category: flags.TxPoolCategory,
+ }
+ TxPoolJournalRemotesFlag = &cli.BoolFlag{
+ Name: "txpool.journalremotes",
+ Usage: "Includes remote transactions in the journal",
Category: flags.TxPoolCategory,
}
TxPoolRejournalFlag = &cli.DurationFlag{
@@ -434,6 +468,12 @@ MinerGasLimitFlag = &cli.Uint64Flag{
Name: "miner.gaslimit",
Usage: "Target gas ceiling for mined blocks",
Value: ethconfig.Defaults.Miner.GasCeil,
+ Category: flags.MinerCategory,
+ }
+ MinerEffectiveGasLimitFlag = &cli.Uint64Flag{
+ Name: "miner.effectivegaslimit",
+ Usage: "If non-zero, an effective gas limit to apply in addition to the block header gaslimit.",
+ Value: 0,
Category: flags.MinerCategory,
}
MinerGasPriceFlag = &flags.BigFlag{
@@ -749,13 +789,14 @@ Name: "discovery.v4",
Aliases: []string{"discv4"},
Usage: "Enables the V4 discovery mechanism",
Category: flags.NetworkingCategory,
- Value: true,
+ Value: false,
}
DiscoveryV5Flag = &cli.BoolFlag{
Name: "discovery.v5",
Aliases: []string{"discv5"},
Usage: "Enables the experimental RLPx V5 (Topic Discovery) mechanism",
Category: flags.NetworkingCategory,
+ Value: true,
}
NetrestrictFlag = &cli.StringFlag{
Name: "netrestrict",
@@ -813,6 +854,60 @@ Usage: "Gas price below which gpo will ignore transactions",
Value: ethconfig.Defaults.GPO.IgnorePrice.Int64(),
Category: flags.GasPriceCategory,
}
+ GpoMinSuggestedPriorityFeeFlag = &cli.Int64Flag{
+ Name: "gpo.minsuggestedpriorityfee",
+ Usage: "Minimum transaction priority fee to suggest. Used on OP chains when blocks are not full.",
+ Value: ethconfig.Defaults.GPO.MinSuggestedPriorityFee.Int64(),
+ Category: flags.GasPriceCategory,
+ }
+
+ // Rollup Flags
+ RollupSequencerHTTPFlag = &cli.StringFlag{
+ Name: "rollup.sequencerhttp",
+ Usage: "HTTP endpoint for the sequencer mempool",
+ Category: flags.RollupCategory,
+ }
+
+ RollupHistoricalRPCFlag = &cli.StringFlag{
+ Name: "rollup.historicalrpc",
+ Usage: "RPC endpoint for historical data.",
+ Category: flags.RollupCategory,
+ }
+
+ RollupHistoricalRPCTimeoutFlag = &cli.StringFlag{
+ Name: "rollup.historicalrpctimeout",
+ Usage: "Timeout for historical RPC requests.",
+ Value: "5s",
+ Category: flags.RollupCategory,
+ }
+
+ RollupDisableTxPoolGossipFlag = &cli.BoolFlag{
+ Name: "rollup.disabletxpoolgossip",
+ Usage: "Disable transaction pool gossip.",
+ Category: flags.RollupCategory,
+ }
+ RollupEnableTxPoolAdmissionFlag = &cli.BoolFlag{
+ Name: "rollup.enabletxpooladmission",
+ Usage: "Add RPC-submitted transactions to the txpool (on by default if --rollup.sequencerhttp is not set).",
+ Category: flags.RollupCategory,
+ }
+ RollupComputePendingBlock = &cli.BoolFlag{
+ Name: "rollup.computependingblock",
+ Usage: "By default the pending block equals the latest block to save resources and not leak txs from the tx-pool, this flag enables computing of the pending block from the tx-pool instead.",
+ Category: flags.RollupCategory,
+ }
+ RollupHaltOnIncompatibleProtocolVersionFlag = &cli.StringFlag{
+ Name: "rollup.halt",
+ Usage: "Opt-in option to halt on incompatible protocol version requirements of the given level (major/minor/patch/none), as signaled through the Engine API by the rollup node",
+ Category: flags.RollupCategory,
+ }
+ RollupSuperchainUpgradesFlag = &cli.BoolFlag{
+ Name: "rollup.superchain-upgrades",
+ Aliases: []string{"beta.rollup.superchain-upgrades"},
+ Usage: "Apply superchain-registry config changes to the local chain-configuration",
+ Category: flags.RollupCategory,
+ Value: true,
+ }
// Metrics flags
MetricsEnabledFlag = &cli.BoolFlag{
@@ -918,7 +1013,7 @@ SepoliaFlag,
HoleskyFlag,
}
// NetworkFlags is the flag group of all built-in supported networks.
- NetworkFlags = append([]cli.Flag{MainnetFlag}, TestnetFlags...)
+ NetworkFlags = append([]cli.Flag{MainnetFlag, OPNetworkFlag}, TestnetFlags...)
// DatabaseFlags is the flag group of all database flags.
DatabaseFlags = []cli.Flag{
@@ -944,6 +1039,9 @@ return filepath.Join(path, "sepolia")
}
if ctx.Bool(HoleskyFlag.Name) {
return filepath.Join(path, "holesky")
+ }
+ if ctx.IsSet(OPNetworkFlag.Name) {
+ return filepath.Join(path, ctx.String(OPNetworkFlag.Name))
}
return path
}
@@ -1036,6 +1134,13 @@ case ctx.IsSet(BootnodesFlag.Name):
urls = SplitAndTrim(ctx.String(BootnodesFlag.Name))
case cfg.BootstrapNodesV5 != nil:
return // already set, don't apply defaults.
+ case ctx.IsSet(OPNetworkFlag.Name):
+ network := ctx.String(OPNetworkFlag.Name)
+ if strings.Contains(strings.ToLower(network), "mainnet") {
+ urls = params.V5OPBootnodes
+ } else {
+ urls = params.V5OPTestnetBootnodes
+ }
}
cfg.BootstrapNodesV5 = make([]*enode.Node, 0, len(urls))
@@ -1434,6 +1539,8 @@ case ctx.Bool(SepoliaFlag.Name) && cfg.DataDir == node.DefaultDataDir():
cfg.DataDir = filepath.Join(node.DefaultDataDir(), "sepolia")
case ctx.Bool(HoleskyFlag.Name) && cfg.DataDir == node.DefaultDataDir():
cfg.DataDir = filepath.Join(node.DefaultDataDir(), "holesky")
+ case ctx.IsSet(OPNetworkFlag.Name) && cfg.DataDir == node.DefaultDataDir():
+ cfg.DataDir = filepath.Join(node.DefaultDataDir(), ctx.String(OPNetworkFlag.Name))
}
}
@@ -1450,6 +1557,9 @@ }
if ctx.IsSet(GpoIgnoreGasPriceFlag.Name) {
cfg.IgnorePrice = big.NewInt(ctx.Int64(GpoIgnoreGasPriceFlag.Name))
}
+ if ctx.IsSet(GpoMinSuggestedPriorityFeeFlag.Name) {
+ cfg.MinSuggestedPriorityFee = big.NewInt(ctx.Int64(GpoMinSuggestedPriorityFeeFlag.Name))
+ }
}
func setTxPool(ctx *cli.Context, cfg *legacypool.Config) {
@@ -1469,6 +1579,9 @@ }
if ctx.IsSet(TxPoolJournalFlag.Name) {
cfg.Journal = ctx.String(TxPoolJournalFlag.Name)
}
+ if ctx.IsSet(TxPoolJournalRemotesFlag.Name) {
+ cfg.JournalRemote = ctx.Bool(TxPoolJournalRemotesFlag.Name)
+ }
if ctx.IsSet(TxPoolRejournalFlag.Name) {
cfg.Rejournal = ctx.Duration(TxPoolRejournalFlag.Name)
}
@@ -1492,6 +1605,11 @@ cfg.GlobalQueue = ctx.Uint64(TxPoolGlobalQueueFlag.Name)
}
if ctx.IsSet(TxPoolLifetimeFlag.Name) {
cfg.Lifetime = ctx.Duration(TxPoolLifetimeFlag.Name)
+ }
+ if ctx.IsSet(MinerEffectiveGasLimitFlag.Name) {
+ // While technically this is a miner config parameter, we also want the txpool to enforce
+ // it to avoid accepting transactions that can never be included in a block.
+ cfg.EffectiveGasCeil = ctx.Uint64(MinerEffectiveGasLimitFlag.Name)
}
}
@@ -1502,6 +1620,9 @@ }
if ctx.IsSet(MinerGasLimitFlag.Name) {
cfg.GasCeil = ctx.Uint64(MinerGasLimitFlag.Name)
}
+ if ctx.IsSet(MinerEffectiveGasLimitFlag.Name) {
+ cfg.EffectiveGasCeil = ctx.Uint64(MinerEffectiveGasLimitFlag.Name)
+ }
if ctx.IsSet(MinerGasPriceFlag.Name) {
cfg.GasPrice = flags.GlobalBig(ctx, MinerGasPriceFlag.Name)
}
@@ -1510,6 +1631,9 @@ cfg.Recommit = ctx.Duration(MinerRecommitIntervalFlag.Name)
}
if ctx.IsSet(MinerNewPayloadTimeout.Name) {
cfg.NewPayloadTimeout = ctx.Duration(MinerNewPayloadTimeout.Name)
+ }
+ if ctx.IsSet(RollupComputePendingBlock.Name) {
+ cfg.RollupComputePendingBlock = ctx.Bool(RollupComputePendingBlock.Name)
}
}
@@ -1585,7 +1709,7 @@
// SetEthConfig applies eth-related command line flags to the config.
func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
// Avoid conflicting network flags
- CheckExclusive(ctx, MainnetFlag, DeveloperFlag, GoerliFlag, SepoliaFlag, HoleskyFlag)
+ CheckExclusive(ctx, MainnetFlag, DeveloperFlag, GoerliFlag, SepoliaFlag, HoleskyFlag, OPNetworkFlag)
CheckExclusive(ctx, DeveloperFlag, ExternalSignerFlag) // Can't use both ephemeral unlocked and external signer
// Set configurations from CLI flags
@@ -1728,6 +1852,20 @@ } else {
cfg.EthDiscoveryURLs = SplitAndTrim(urls)
}
}
+ // Only configure sequencer http flag if we're running in verifier mode i.e. --mine is disabled.
+ if ctx.IsSet(RollupSequencerHTTPFlag.Name) && !ctx.IsSet(MiningEnabledFlag.Name) {
+ cfg.RollupSequencerHTTP = ctx.String(RollupSequencerHTTPFlag.Name)
+ }
+ if ctx.IsSet(RollupHistoricalRPCFlag.Name) {
+ cfg.RollupHistoricalRPC = ctx.String(RollupHistoricalRPCFlag.Name)
+ }
+ if ctx.IsSet(RollupHistoricalRPCTimeoutFlag.Name) {
+ cfg.RollupHistoricalRPCTimeout = ctx.Duration(RollupHistoricalRPCTimeoutFlag.Name)
+ }
+ cfg.RollupDisableTxPoolGossip = ctx.Bool(RollupDisableTxPoolGossipFlag.Name)
+ cfg.RollupDisableTxPoolAdmission = cfg.RollupSequencerHTTP != "" && !ctx.Bool(RollupEnableTxPoolAdmissionFlag.Name)
+ cfg.RollupHaltOnIncompatibleProtocolVersion = ctx.String(RollupHaltOnIncompatibleProtocolVersionFlag.Name)
+ cfg.ApplySuperchainUpgrades = ctx.Bool(RollupSuperchainUpgradesFlag.Name)
// Override any default configs for hard coded networks.
switch {
case ctx.Bool(MainnetFlag.Name):
@@ -1829,6 +1967,12 @@ }
if !ctx.IsSet(MinerGasPriceFlag.Name) {
cfg.Miner.GasPrice = big.NewInt(1)
}
+ case ctx.IsSet(OPNetworkFlag.Name):
+ genesis := MakeGenesis(ctx)
+ if !ctx.IsSet(NetworkIdFlag.Name) {
+ cfg.NetworkId = genesis.Config.ChainID.Uint64()
+ }
+ cfg.Genesis = genesis
default:
if cfg.NetworkId == 1 {
SetDNSDiscoveryDefaults(cfg, params.MainnetGenesisHash)
@@ -2020,8 +2164,7 @@ }
func IsNetworkPreset(ctx *cli.Context) bool {
for _, flag := range NetworkFlags {
- bFlag, _ := flag.(*cli.BoolFlag)
- if ctx.IsSet(bFlag.Name) {
+ if ctx.IsSet(flag.Names()[0]) {
return true
}
}
@@ -2063,6 +2206,17 @@ case ctx.Bool(SepoliaFlag.Name):
genesis = core.DefaultSepoliaGenesisBlock()
case ctx.Bool(GoerliFlag.Name):
genesis = core.DefaultGoerliGenesisBlock()
+ case ctx.IsSet(OPNetworkFlag.Name):
+ name := ctx.String(OPNetworkFlag.Name)
+ ch, err := params.OPStackChainIDByName(name)
+ if err != nil {
+ Fatalf("failed to load OP-Stack chain %q: %v", name, err)
+ }
+ genesis, err := core.LoadOPStackGenesis(ch)
+ if err != nil {
+ Fatalf("failed to load genesis for OP-Stack chain %q (%d): %v", name, ch, err)
+ }
+ return genesis
case ctx.Bool(DeveloperFlag.Name):
Fatalf("Developer chains are ephemeral")
}
diff --git go-ethereum/internal/flags/categories.go op-geth/internal/flags/categories.go
index 3ff0767921b9f97755b09d818ca7ca55e4f79c8a..fe2e6d29d4583b57ad9fdbb875dfc68e1eb12faa 100644
--- go-ethereum/internal/flags/categories.go
+++ op-geth/internal/flags/categories.go
@@ -32,6 +32,7 @@ NetworkingCategory = "NETWORKING"
MinerCategory = "MINER"
GasPriceCategory = "GAS PRICE ORACLE"
VMCategory = "VIRTUAL MACHINE"
+ RollupCategory = "ROLLUP NODE"
LoggingCategory = "LOGGING AND DEBUGGING"
MetricsCategory = "METRICS AND STATS"
MiscCategory = "MISC"
Versioning
+68
-17
List the op-geth and upstream go-ethereum versions.
diff --git go-ethereum/build/ci.go op-geth/build/ci.go
index 4d8dba6ce23405e8ab0ecf9d9cb6fadec1819f48..8dca8a492008b9774d6a2d251cf517f95dbb9832 100644
--- go-ethereum/build/ci.go
+++ op-geth/build/ci.go
@@ -53,10 +53,10 @@ "strings"
"time"
"github.com/cespare/cp"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto/signify"
- "github.com/ethereum/go-ethereum/internal/build"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto/signify"
+ "github.com/tenderly/op-geth/internal/build"
+ "github.com/tenderly/op-geth/params"
)
var (
@@ -244,8 +244,11 @@ // buildFlags returns the go tool flags for building.
func buildFlags(env build.Environment, staticLinking bool, buildTags []string) (flags []string) {
var ld []string
if env.Commit != "" {
- ld = append(ld, "-X", "github.com/ethereum/go-ethereum/internal/version.gitCommit="+env.Commit)
- ld = append(ld, "-X", "github.com/ethereum/go-ethereum/internal/version.gitDate="+env.Date)
+ ld = append(ld, "-X", "github.com/tenderly/op-geth/internal/version.gitCommit="+env.Commit)
+ ld = append(ld, "-X", "github.com/tenderly/op-geth/internal/version.gitDate="+env.Date)
+ }
+ if env.Tag != "" {
+ ld = append(ld, "-X", "github.com/tenderly/op-geth/params.gitTag="+env.Tag)
}
// Strip DWARF on darwin. This used to be required for certain things,
// and there is no downside to this, so we just keep doing it.
@@ -541,7 +544,7 @@ switch {
case env.Branch == "master":
tags = []string{"latest"}
case strings.HasPrefix(env.Tag, "v1."):
- tags = []string{"stable", fmt.Sprintf("release-1.%d", params.VersionMinor), "v" + params.Version}
+ tags = []string{"stable", fmt.Sprintf("release-1.%d", params.OPVersionMinor), "v" + params.Version}
}
// If architecture specific image builds are requested, build and push them
if *image {
@@ -833,10 +836,10 @@ return wdflag
}
func isUnstableBuild(env build.Environment) bool {
- if env.Tag != "" {
- return false
+ if env.Tag == "untagged" || env.Tag == "" {
+ return true
}
- return true
+ return false
}
type debPackage struct {
diff --git go-ethereum/cmd/geth/misccmd.go op-geth/cmd/geth/misccmd.go
index f3530c30fb69fe08024d9f62a1a377d416c684d9..324433b32b83c803986ed0a798ced4b74ffddc90 100644
--- go-ethereum/cmd/geth/misccmd.go
+++ op-geth/cmd/geth/misccmd.go
@@ -22,8 +22,8 @@ "os"
"runtime"
"strings"
- "github.com/ethereum/go-ethereum/internal/version"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/internal/version"
+ "github.com/tenderly/op-geth/params"
"github.com/urfave/cli/v2"
)
@@ -80,6 +80,7 @@ }
if git.Date != "" {
fmt.Println("Git Commit Date:", git.Date)
}
+ fmt.Println("Upstream Version:", params.GethVersionWithMeta)
fmt.Println("Architecture:", runtime.GOARCH)
fmt.Println("Go Version:", runtime.Version())
fmt.Println("Operating System:", runtime.GOOS)
diff --git go-ethereum/params/version.go op-geth/params/version.go
index a2c258ff58cb604141f6489e5d6d7211d10763c5..86adc36db7229844c6eb8b039fbf5422c0f6383d 100644
--- go-ethereum/params/version.go
+++ op-geth/params/version.go
@@ -18,8 +18,11 @@ package params
import (
"fmt"
+ "regexp"
+ "strconv"
)
+// Version is the version of upstream geth
const (
VersionMajor = 1 // Major version component of the current release
VersionMinor = 13 // Minor version component of the current release
@@ -27,14 +30,58 @@ VersionPatch = 15 // Patch version component of the current release
VersionMeta = "stable" // Version metadata to append to the version string
)
+// OPVersion is the version of op-geth
+var (
+ OPVersionMajor = 0 // Major version component of the current release
+ OPVersionMinor = 1 // Minor version component of the current release
+ OPVersionPatch = 0 // Patch version component of the current release
+ OPVersionMeta = "untagged" // Version metadata to append to the version string
+)
+
+// This is set at build-time by the linker when the build is done by build/ci.go.
+var gitTag string
+
+// Override the version variables if the gitTag was set at build time.
+var _ = func() (_ string) {
+ semver := regexp.MustCompile(`^v([0-9]+)\.([0-9]+)\.([0-9]+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+)?$`)
+ version := semver.FindStringSubmatch(gitTag)
+ if version == nil {
+ return
+ }
+ if version[4] == "" {
+ version[4] = "stable"
+ }
+ OPVersionMajor, _ = strconv.Atoi(version[1])
+ OPVersionMinor, _ = strconv.Atoi(version[2])
+ OPVersionPatch, _ = strconv.Atoi(version[3])
+ OPVersionMeta = version[4]
+ return
+}()
+
// Version holds the textual version string.
var Version = func() string {
- return fmt.Sprintf("%d.%d.%d", VersionMajor, VersionMinor, VersionPatch)
+ if OPVersionMeta == "untagged" {
+ return OPVersionMeta
+ }
+ return fmt.Sprintf("%d.%d.%d", OPVersionMajor, OPVersionMinor, OPVersionPatch)
}()
// VersionWithMeta holds the textual version string including the metadata.
var VersionWithMeta = func() string {
- v := Version
+ if OPVersionMeta != "untagged" {
+ return Version + "-" + OPVersionMeta
+ }
+ return Version
+}()
+
+// GethVersion holds the textual geth version string.
+var GethVersion = func() string {
+ return fmt.Sprintf("%d.%d.%d", VersionMajor, VersionMinor, VersionPatch)
+}()
+
+// GethVersionWithMeta holds the textual geth version string including the metadata.
+var GethVersionWithMeta = func() string {
+ v := GethVersion
if VersionMeta != "" {
v += "-" + VersionMeta
}
@@ -46,8 +93,8 @@ // "1.8.11-dea1ce05" for stable releases, or "1.8.13-unstable-21c059b6" for unstable
// releases.
func ArchiveVersion(gitCommit string) string {
vsn := Version
- if VersionMeta != "stable" {
- vsn += "-" + VersionMeta
+ if OPVersionMeta != "stable" {
+ vsn += "-" + OPVersionMeta
}
if len(gitCommit) >= 8 {
vsn += "-" + gitCommit[:8]
@@ -60,7 +107,7 @@ vsn := VersionWithMeta
if len(gitCommit) >= 8 {
vsn += "-" + gitCommit[:8]
}
- if (VersionMeta != "stable") && (gitDate != "") {
+ if (OPVersionMeta != "stable") && (gitDate != "") {
vsn += "-" + gitDate
}
return vsn
Node config
+41
-19
diff --git go-ethereum/eth/ethconfig/config.go op-geth/eth/ethconfig/config.go
index ad664afb5bd1fa68165f23bfd30ef5c82eb0a7e0..3b0f9be48228547eba2ac06ec1c2bf56713086db 100644
--- go-ethereum/eth/ethconfig/config.go
+++ op-geth/eth/ethconfig/config.go
@@ -21,29 +21,30 @@ import (
"errors"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/consensus/clique"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/txpool/blobpool"
- "github.com/ethereum/go-ethereum/core/txpool/legacypool"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/gasprice"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/miner"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/consensus/clique"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/txpool/blobpool"
+ "github.com/tenderly/op-geth/core/txpool/legacypool"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/gasprice"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/miner"
+ "github.com/tenderly/op-geth/params"
)
// FullNodeGPO contains default gasprice oracle settings for full node.
var FullNodeGPO = gasprice.Config{
- Blocks: 20,
- Percentile: 60,
- MaxHeaderHistory: 1024,
- MaxBlockHistory: 1024,
- MaxPrice: gasprice.DefaultMaxPrice,
- IgnorePrice: gasprice.DefaultIgnorePrice,
+ Blocks: 20,
+ Percentile: 60,
+ MaxHeaderHistory: 1024,
+ MaxBlockHistory: 1024,
+ MaxPrice: gasprice.DefaultMaxPrice,
+ IgnorePrice: gasprice.DefaultIgnorePrice,
+ MinSuggestedPriorityFee: gasprice.DefaultMinSuggestedPriorityFee,
}
// Defaults contains default settings for use on the Ethereum main net.
@@ -159,12 +160,33 @@ OverrideCancun *uint64 `toml:",omitempty"`
// OverrideVerkle (TODO: remove after the fork)
OverrideVerkle *uint64 `toml:",omitempty"`
+
+ OverrideOptimismCanyon *uint64 `toml:",omitempty"`
+
+ OverrideOptimismEcotone *uint64 `toml:",omitempty"`
+
+ OverrideOptimismFjord *uint64 `toml:",omitempty"`
+
+ OverrideOptimismInterop *uint64 `toml:",omitempty"`
+
+ // ApplySuperchainUpgrades requests the node to load chain-configuration from the superchain-registry.
+ ApplySuperchainUpgrades bool `toml:",omitempty"`
+
+ RollupSequencerHTTP string
+ RollupHistoricalRPC string
+ RollupHistoricalRPCTimeout time.Duration
+ RollupDisableTxPoolGossip bool
+ RollupDisableTxPoolAdmission bool
+ RollupHaltOnIncompatibleProtocolVersion string
}
// CreateConsensusEngine creates a consensus engine for the given chain config.
// Clique is allowed for now to live standalone, but ethash is forbidden and can
// only exist on already merged networks.
func CreateConsensusEngine(config *params.ChainConfig, db ethdb.Database) (consensus.Engine, error) {
+ if config.Optimism != nil {
+ return beacon.New(&beacon.OpLegacy{}), nil
+ }
// If proof-of-authority is requested, set it up
if config.Clique != nil {
return beacon.New(clique.New(config.Clique, db)), nil
Tx gossip disable option
+54
-27
diff --git go-ethereum/eth/handler.go op-geth/eth/handler.go
index 0343a5787012498a764d8814a48a7c2488c52519..21d8529f6f5bfc8e4deefe834843669650a13e0f 100644
--- go-ethereum/eth/handler.go
+++ op-geth/eth/handler.go
@@ -24,24 +24,24 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/forkid"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/fetcher"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/eth/protocols/snap"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/forkid"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/fetcher"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/eth/protocols/snap"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/triedb/pathdb"
)
const (
@@ -93,6 +93,7 @@ Sync downloader.SyncMode // Whether to snap or full sync
BloomCache uint64 // Megabytes to alloc for snap sync bloom
EventMux *event.TypeMux // Legacy event mux, deprecate for `feed`
RequiredBlocks map[uint64]common.Hash // Hard coded map of required block hashes for sync challenges
+ NoTxGossip bool // Disable P2P transaction gossip
}
type handler struct {
@@ -107,6 +108,8 @@ txpool txPool
chain *core.BlockChain
maxPeers int
+ noTxGossip bool
+
downloader *downloader.Downloader
blockFetcher *fetcher.BlockFetcher
txFetcher *fetcher.TxFetcher
@@ -142,6 +145,7 @@ forkFilter: forkid.NewFilter(config.Chain),
eventMux: config.EventMux,
database: config.Database,
txpool: config.TxPool,
+ noTxGossip: config.NoTxGossip,
chain: config.Chain,
peers: newPeerSet(),
merger: config.Merger,
@@ -169,9 +173,10 @@ log.Warn("Switch sync mode from full sync to snap sync", "reason", "head state missing")
}
} else {
head := h.chain.CurrentBlock()
- if head.Number.Uint64() > 0 && h.chain.HasState(head.Root) {
+ if head.Number.Uint64() > 0 && h.chain.HasState(head.Root) && (!config.Chain.Config().IsOptimism() || head.Number.Cmp(config.Chain.Config().BedrockBlock) != 0) {
// Print warning log if database is not empty to run snap sync.
- log.Warn("Switch sync mode from snap sync to full sync", "reason", "snap sync complete")
+ // For OP chains, snap sync from bedrock block is allowed.
+ log.Warn("Switch sync mode from snap sync to full sync")
} else {
// If snap sync was requested and our database is empty, grant it
h.snapSync.Store(true)
@@ -182,8 +187,14 @@ // If snap sync is requested but snapshots are disabled, fail loudly
if h.snapSync.Load() && config.Chain.Snapshots() == nil {
return nil, errors.New("snap sync not supported with snapshots disabled")
}
+ // if the chainID is set, pass it to the downloader for use in sync
+ // this might not be set in tests
+ var chainID uint64
+ if cid := h.chain.Config().ChainID; cid != nil {
+ chainID = cid.Uint64()
+ }
// Construct the downloader (long sync)
- h.downloader = downloader.New(config.Database, h.eventMux, h.chain, nil, h.removePeer, h.enableSyncedFeatures)
+ h.downloader = downloader.New(config.Database, h.eventMux, h.chain, nil, h.removePeer, h.enableSyncedFeatures, chainID)
if ttd := h.chain.Config().TerminalTotalDifficulty; ttd != nil {
if h.chain.Config().TerminalTotalDifficultyPassed {
log.Info("Chain post-merge, sync via beacon client")
diff --git go-ethereum/eth/handler_eth.go op-geth/eth/handler_eth.go
index f1284c10e637e5d3dd9ee47a3652aa3cfaaba60e..8cdf70d8bdb4081c7ff8eb3fd9a037293a1d6da6 100644
--- go-ethereum/eth/handler_eth.go
+++ op-geth/eth/handler_eth.go
@@ -22,11 +22,11 @@ "fmt"
"math/big"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// ethHandler implements the eth.Backend interface to handle the various network
@@ -34,7 +34,20 @@ // packets that are sent as replies or broadcasts.
type ethHandler handler
func (h *ethHandler) Chain() *core.BlockChain { return h.chain }
-func (h *ethHandler) TxPool() eth.TxPool { return h.txpool }
+
+// NilPool satisfies the TxPool interface but does not return any tx in the
+// pool. It is used to disable transaction gossip.
+type NilPool struct{}
+
+// NilPool Get always returns nil
+func (n NilPool) Get(hash common.Hash) *types.Transaction { return nil }
+
+func (h *ethHandler) TxPool() eth.TxPool {
+ if h.noTxGossip {
+ return &NilPool{}
+ }
+ return h.txpool
+}
// RunPeer is invoked when a peer joins on the `eth` protocol.
func (h *ethHandler) RunPeer(peer *eth.Peer, hand eth.Handler) error {
@@ -52,6 +65,9 @@
// AcceptTxs retrieves whether transaction processing is enabled on the node
// or if inbound transactions should simply be dropped.
func (h *ethHandler) AcceptTxs() bool {
+ if h.noTxGossip {
+ return false
+ }
return h.synced.Load()
}
Warn on missing hardfork data
+26
-22
diff --git go-ethereum/core/blockchain.go op-geth/core/blockchain.go
index b1bbc3d5982ded15ea3659b8141a85f5fc842a65..356333331586a52922e53b8d05524df64ba67f20 100644
--- go-ethereum/core/blockchain.go
+++ op-geth/core/blockchain.go
@@ -28,28 +28,28 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/common/prque"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/internal/syncx"
- "github.com/ethereum/go-ethereum/internal/version"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/hashdb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/common/prque"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/state/snapshot"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/internal/syncx"
+ "github.com/tenderly/op-geth/internal/version"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/hashdb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
"golang.org/x/exp/slices"
)
@@ -285,6 +285,10 @@ log.Info(line)
}
log.Info(strings.Repeat("-", 153))
log.Info("")
+
+ if chainConfig.IsOptimism() && chainConfig.RegolithTime == nil {
+ log.Warn("Optimism RegolithTime has not been set")
+ }
bc := &BlockChain{
chainConfig: chainConfig,
Optional Engine API extensions
+66
-0
diff --git go-ethereum/eth/catalyst/superchain.go op-geth/eth/catalyst/superchain.go
new file mode 100644
index 0000000000000000000000000000000000000000..457d3c8435c9cefef7e72b979875616d44ccbbc8
--- /dev/null
+++ op-geth/eth/catalyst/superchain.go
@@ -0,0 +1,66 @@
+package catalyst
+
+import (
+ "fmt"
+
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/params"
+)
+
+var (
+ requiredProtocolDeltaGauge = metrics.NewRegisteredGauge("superchain/required/delta", nil)
+ recommendedProtocolDeltaGauge = metrics.NewRegisteredGauge("superchain/recommended/delta", nil)
+)
+
+type SuperchainSignal struct {
+ Recommended params.ProtocolVersion `json:"recommended"`
+ Required params.ProtocolVersion `json:"required"`
+}
+
+func (api *ConsensusAPI) SignalSuperchainV1(signal *SuperchainSignal) (params.ProtocolVersion, error) {
+ if signal == nil {
+ log.Info("Received empty superchain version signal", "local", params.OPStackSupport)
+ return params.OPStackSupport, nil
+ }
+ // update metrics and log any warnings/info
+ requiredProtocolDeltaGauge.Update(int64(params.OPStackSupport.Compare(signal.Required)))
+ recommendedProtocolDeltaGauge.Update(int64(params.OPStackSupport.Compare(signal.Recommended)))
+ logger := log.New("local", params.OPStackSupport, "required", signal.Required, "recommended", signal.Recommended)
+ LogProtocolVersionSupport(logger, params.OPStackSupport, signal.Recommended, "recommended")
+ LogProtocolVersionSupport(logger, params.OPStackSupport, signal.Required, "required")
+
+ if err := api.eth.HandleRequiredProtocolVersion(signal.Required); err != nil {
+ log.Error("Failed to handle required protocol version", "err", err, "required", signal.Required)
+ return params.OPStackSupport, err
+ }
+
+ return params.OPStackSupport, nil
+}
+
+func LogProtocolVersionSupport(logger log.Logger, local, other params.ProtocolVersion, name string) {
+ switch local.Compare(other) {
+ case params.AheadMajor:
+ logger.Info(fmt.Sprintf("Ahead with major %s protocol version change", name))
+ case params.AheadMinor, params.AheadPatch, params.AheadPrerelease:
+ logger.Debug(fmt.Sprintf("Ahead with compatible %s protocol version change", name))
+ case params.Matching:
+ logger.Debug(fmt.Sprintf("Latest %s protocol version is supported", name))
+ case params.OutdatedMajor:
+ logger.Error(fmt.Sprintf("Outdated with major %s protocol change", name))
+ case params.OutdatedMinor:
+ logger.Warn(fmt.Sprintf("Outdated with minor backward-compatible %s protocol change", name))
+ case params.OutdatedPatch:
+ logger.Info(fmt.Sprintf("Outdated with support backward-compatible %s protocol change", name))
+ case params.OutdatedPrerelease:
+ logger.Debug(fmt.Sprintf("New %s protocol pre-release is available", name))
+ case params.DiffBuild:
+ logger.Debug(fmt.Sprintf("Ignoring %s protocolversion signal, local build is different", name))
+ case params.DiffVersionType:
+ logger.Warn(fmt.Sprintf("Failed to recognize %s protocol version signal version-type", name))
+ case params.EmptyVersion:
+ logger.Debug(fmt.Sprintf("No %s protocol version available to check", name))
+ case params.InvalidVersion:
+ logger.Warn(fmt.Sprintf("Invalid protocol version comparison with %s", name))
+ }
+}
Support legacy DBs when snap-syncing
+30
-22
Snap-sync does not serve unprefixed code by default.
diff --git go-ethereum/core/blockchain_reader.go op-geth/core/blockchain_reader.go
index 9e8e3bd4195af62293c8db16002bed95779ae3fa..cf6273feccae713b75b7be4904ca2f9ecb03090d 100644
--- go-ethereum/core/blockchain_reader.go
+++ op-geth/core/blockchain_reader.go
@@ -20,17 +20,17 @@ import (
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/state/snapshot"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/triedb"
)
// CurrentHeader retrieves the current head header of the canonical chain. The
@@ -344,6 +344,14 @@ }
// TODO(rjl493456442) The associated account address is also required
// in Verkle scheme. Fix it once snap-sync is supported for Verkle.
return bc.stateCache.(codeReader).ContractCodeWithPrefix(common.Address{}, hash)
+}
+
+// ContractCode retrieves a blob of data associated with a contract hash
+// either from ephemeral in-memory cache, or from persistent storage.
+// This is a legacy-method, replaced by ContractCodeWithPrefix,
+// but required for old databases to serve snap-sync.
+func (bc *BlockChain) ContractCode(hash common.Hash) ([]byte, error) {
+ return bc.stateCache.ContractCode(common.Address{}, hash)
}
// State returns a new mutable state based on the current HEAD block.
diff --git go-ethereum/eth/protocols/snap/handler.go op-geth/eth/protocols/snap/handler.go
index bd7ce9e71543c944c1a8e1ff2dd2dfcaa95d236f..a8d47840e2945427ba934e07f55dbcf3ba093719 100644
--- go-ethereum/eth/protocols/snap/handler.go
+++ op-geth/eth/protocols/snap/handler.go
@@ -21,16 +21,16 @@ "bytes"
"fmt"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/trie/trienode"
)
const (
@@ -469,7 +469,7 @@ if hash == types.EmptyCodeHash {
// Peers should not request the empty code, but if they do, at
// least sent them back a correct response without db lookups
codes = append(codes, []byte{})
- } else if blob, err := chain.ContractCodeWithPrefix(hash); err == nil {
+ } else if blob, err := chain.ContractCode(hash); err == nil {
codes = append(codes, blob)
bytes += uint64(len(blob))
}
Historical data for Snap-sync
+161
-13
Snap-sync has access to trusted Deposit Transaction Nonce Data.
diff --git go-ethereum/eth/downloader/downloader.go op-geth/eth/downloader/downloader.go
index 6e7c5dcf02c8ee82e8dec503bebbcb0a259ce195..76719bf368d5660a9c1f461790b847d45ff7e6b0 100644
--- go-ethereum/eth/downloader/downloader.go
+++ op-geth/eth/downloader/downloader.go
@@ -25,17 +25,17 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/protocols/snap"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state/snapshot"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/protocols/snap"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/triedb"
)
var (
@@ -156,6 +156,9 @@ // Progress reporting metrics
syncStartBlock uint64 // Head snap block when Geth was started
syncStartTime time.Time // Time instance when chain sync started
syncLogTime time.Time // Time instance when status was last reported
+
+ // Chain ID for downloaders to reference
+ chainID uint64
}
// LightChain encapsulates functions required to synchronise a light chain.
@@ -216,7 +219,7 @@ TrieDB() *triedb.Database
}
// New creates a new downloader to fetch hashes and blocks from remote peers.
-func New(stateDb ethdb.Database, mux *event.TypeMux, chain BlockChain, lightchain LightChain, dropPeer peerDropFn, success func()) *Downloader {
+func New(stateDb ethdb.Database, mux *event.TypeMux, chain BlockChain, lightchain LightChain, dropPeer peerDropFn, success func(), chainID uint64) *Downloader {
if lightchain == nil {
lightchain = chain
}
@@ -233,6 +236,7 @@ quitCh: make(chan struct{}),
SnapSyncer: snap.NewSyncer(stateDb, chain.TrieDB().Scheme()),
stateSyncStart: make(chan *stateSync),
syncStartBlock: chain.CurrentSnapBlock().Number.Uint64(),
+ chainID: chainID,
}
// Create the post-merge skeleton syncer and start the process
dl.skeleton = newSkeleton(stateDb, dl.peers, dropPeer, newBeaconBackfiller(dl, success))
@@ -1719,7 +1723,7 @@ blocks := make([]*types.Block, len(results))
receipts := make([]types.Receipts, len(results))
for i, result := range results {
blocks[i] = types.NewBlockWithHeader(result.Header).WithBody(result.Transactions, result.Uncles).WithWithdrawals(result.Withdrawals)
- receipts[i] = result.Receipts
+ receipts[i] = correctReceipts(result.Receipts, result.Transactions, blocks[i].NumberU64(), d.chainID)
}
if index, err := d.blockchain.InsertReceiptChain(blocks, receipts, d.ancientLimit); err != nil {
log.Debug("Downloaded item processing failed", "number", results[index].Header.Number, "hash", results[index].Header.Hash(), "err", err)
diff --git go-ethereum/eth/downloader/receiptreference.go op-geth/eth/downloader/receiptreference.go
new file mode 100644
index 0000000000000000000000000000000000000000..b97f7c06211bd00c518935737454b7282c2e2a56
--- /dev/null
+++ op-geth/eth/downloader/receiptreference.go
@@ -0,0 +1,144 @@
+package downloader
+
+import (
+ "bytes"
+ "embed"
+ "encoding/gob"
+ "fmt"
+ "path"
+ "strings"
+
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+)
+
+// userDepositNonces is a struct to hold the reference data for user deposits
+// The reference data is used to correct the deposit nonce in the receipts
+type userDepositNonces struct {
+ ChainID uint64
+ First uint64
+ Last uint64 // non inclusive
+ Results map[uint64][]uint64
+}
+
+var (
+ systemAddress = common.HexToAddress("0xDeaDDEaDDeAdDeAdDEAdDEaddeAddEAdDEAd0001")
+ receiptReferencePath = "userDepositData"
+ //go:embed userDepositData/*.gob
+ receiptReference embed.FS
+ userDepositNoncesAlreadySearched = map[uint64]bool{}
+ userDepositNoncesReference = map[uint64]userDepositNonces{}
+)
+
+// lazy load the reference data for the requested chain
+// if this chain data was already requested, returns early
+func initReceiptReferences(chainID uint64) {
+ // if already loaded, return
+ if userDepositNoncesAlreadySearched[chainID] {
+ return
+ }
+ // look for a file prefixed by the chainID
+ fPrefix := fmt.Sprintf("%d.", chainID)
+ files, err := receiptReference.ReadDir(receiptReferencePath)
+ if err != nil {
+ log.Warn("Receipt Correction: Failed to read reference directory", "err", err)
+ return
+ }
+ // mark as loaded so we don't try again, even if no files match
+ userDepositNoncesAlreadySearched[chainID] = true
+ for _, file := range files {
+ // skip files which don't match the prefix
+ if !strings.HasPrefix(file.Name(), fPrefix) {
+ continue
+ }
+ fpath := path.Join(receiptReferencePath, file.Name())
+ bs, err := receiptReference.ReadFile(fpath)
+ if err != nil {
+ log.Warn("Receipt Correction: Failed to read reference data", "err", err)
+ continue
+ }
+ udns := userDepositNonces{}
+ err = gob.NewDecoder(bytes.NewReader(bs)).Decode(&udns)
+ if err != nil {
+ log.Warn("Receipt Correction: Failed to decode reference data", "err", err)
+ continue
+ }
+ userDepositNoncesReference[udns.ChainID] = udns
+ return
+ }
+}
+
+// correctReceipts corrects the deposit nonce in the receipts using the reference data
+// prior to Canyon Hard Fork, DepositNonces were not cryptographically verifiable.
+// As a consequence, the deposit nonces found during Snap Sync may be incorrect.
+// This function inspects transaction data for user deposits, and if it is found to be incorrect, it is corrected.
+// The data used to correct the deposit nonce is stored in the userDepositData directory,
+// and was generated with the receipt reference tool in the optimism monorepo.
+func correctReceipts(receipts types.Receipts, transactions types.Transactions, blockNumber uint64, chainID uint64) types.Receipts {
+ initReceiptReferences(chainID)
+ // if there is no data even after initialization, return the receipts as is
+ depositNoncesForChain, ok := userDepositNoncesReference[chainID]
+ if !ok {
+ log.Trace("Receipt Correction: No data source for chain", "chainID", chainID)
+ return receipts
+ }
+
+ // check that the block number being examined is within the range of the reference data
+ if blockNumber < depositNoncesForChain.First || blockNumber > depositNoncesForChain.Last {
+ log.Trace("Receipt Correction: Block is out of range for receipt reference",
+ "blockNumber", blockNumber,
+ "start", depositNoncesForChain.First,
+ "end", depositNoncesForChain.Last)
+ return receipts
+ }
+
+ // get the block nonces
+ blockNonces, ok := depositNoncesForChain.Results[blockNumber]
+ if !ok {
+ log.Trace("Receipt Correction: Block does not contain user deposits", "blockNumber", blockNumber)
+ return receipts
+ }
+
+ // iterate through the receipts and transactions to correct the deposit nonce
+ // user deposits should always be at the front of the block, but we will check all transactions to be sure
+ udCount := 0
+ for i := 0; i < len(receipts); i++ {
+ r := receipts[i]
+ tx := transactions[i]
+ from, err := types.Sender(types.LatestSignerForChainID(tx.ChainId()), tx)
+ if err != nil {
+ log.Warn("Receipt Correction: Failed to determine sender", "err", err)
+ continue
+ }
+ // break as soon as a non deposit is found
+ if r.Type != types.DepositTxType {
+ break
+ }
+ // ignore any transactions from the system address
+ if from != systemAddress {
+ // prevent index out of range (indicates a problem with the reference data or the block data)
+ if udCount >= len(blockNonces) {
+ log.Warn("Receipt Correction: More user deposits in block than included in reference data", "in_reference", len(blockNonces))
+ break
+ }
+ nonce := blockNonces[udCount]
+ udCount++
+ log.Trace("Receipt Correction: User Deposit detected", "address", from, "nonce", nonce)
+ if nonce != *r.DepositNonce {
+ // correct the deposit nonce
+ // warn because this should not happen unless the data was modified by corruption or a malicious peer
+ // by correcting the nonce, the entire block is still valid for use
+ log.Warn("Receipt Correction: Corrected deposit nonce", "nonce", *r.DepositNonce, "corrected", nonce)
+ r.DepositNonce = &nonce
+ }
+ }
+ }
+ // check for unused reference data (indicates a problem with the reference data or the block data)
+ if udCount < len(blockNonces) {
+ log.Warn("Receipt Correction: More user deposits in reference data than found in block", "in_reference", len(blockNonces), "in_block", udCount)
+ }
+
+ log.Trace("Receipt Correction: Completed", "blockNumber", blockNumber, "userDeposits", udCount, "receipts", len(receipts), "transactions", len(transactions))
+ return receipts
+}
Discv5 node discovery
+11
-10
Fix discv5 option to allow discv5 to be an active source for node-discovery.
diff --git go-ethereum/p2p/server.go op-geth/p2p/server.go
index 975a3bb916624a229a8425465ec37c6efb855ea2..113d4f16d52bec246ea94b5263d5c23de72f44f2 100644
--- go-ethereum/p2p/server.go
+++ op-geth/p2p/server.go
@@ -28,16 +28,16 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/discover"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/p2p/nat"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/discover"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/p2p/nat"
+ "github.com/tenderly/op-geth/p2p/netutil"
"golang.org/x/exp/slices"
)
@@ -579,6 +579,7 @@ srv.DiscV5, err = discover.ListenV5(sconn, srv.localnode, cfg)
if err != nil {
return err
}
+ srv.discmix.AddSource(srv.DiscV5.RandomNodes())
}
// Add protocol-specific discovery sources.
Bootnodes
+24
-1
Discovery bootnode addresses.
diff --git go-ethereum/params/bootnodes.go op-geth/params/bootnodes.go
index 5e2c7c21810234011be103fbd4c03b0d1c57adde..393cd001ff0c936fc09344a3fdc4102e30088045 100644
--- go-ethereum/params/bootnodes.go
+++ op-geth/params/bootnodes.go
@@ -16,7 +16,7 @@ // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
package params
-import "github.com/ethereum/go-ethereum/common"
+import "github.com/tenderly/op-geth/common"
// MainnetBootnodes are the enode URLs of the P2P bootstrap nodes running on
// the main Ethereum network.
@@ -85,6 +85,29 @@ "enr:-Ku4QEWzdnVtXc2Q0ZVigfCGggOVB2Vc1ZCPEc6j21NIFLODSJbvNaef1g4PxhPwl_3kax86YPheFUSLXPRs98vvYsoBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpC1MD8qAAAAAP__________gmlkgnY0gmlwhDZBrP2Jc2VjcDI1NmsxoQM6jr8Rb1ktLEsVcKAPa08wCsKUmvoQ8khiOl_SLozf9IN1ZHCCIyg", // 54.65.172.253 | aws-ap-northeast-1-tokyo
// Nimbus team's bootnodes
"enr:-LK4QA8FfhaAjlb_BXsXxSfiysR7R52Nhi9JBt4F8SPssu8hdE1BXQQEtVDC3qStCW60LSO7hEsVHv5zm8_6Vnjhcn0Bh2F0dG5ldHOIAAAAAAAAAACEZXRoMpC1MD8qAAAAAP__________gmlkgnY0gmlwhAN4aBKJc2VjcDI1NmsxoQJerDhsJ-KxZ8sHySMOCmTO6sHM3iCFQ6VMvLTe948MyYN0Y3CCI4yDdWRwgiOM", // 3.120.104.18 | aws-eu-central-1-frankfurt
"enr:-LK4QKWrXTpV9T78hNG6s8AM6IO4XH9kFT91uZtFg1GcsJ6dKovDOr1jtAAFPnS2lvNltkOGA9k29BUN7lFh_sjuc9QBh2F0dG5ldHOIAAAAAAAAAACEZXRoMpC1MD8qAAAAAP__________gmlkgnY0gmlwhANAdd-Jc2VjcDI1NmsxoQLQa6ai7y9PMN5hpLe5HmiJSlYzMuzP7ZhwRiwHvqNXdoN0Y3CCI4yDdWRwgiOM", // 3.64.117.223 | aws-eu-central-1-frankfurt}
+}
+
+var V5OPBootnodes = []string{
+ // OP Labs
+ "enode://ca2774c3c401325850b2477fd7d0f27911efbf79b1e8b335066516e2bd8c4c9e0ba9696a94b1cb030a88eac582305ff55e905e64fb77fe0edcd70a4e5296d3ec@34.65.175.185:30305",
+ "enode://dd751a9ef8912be1bfa7a5e34e2c3785cc5253110bd929f385e07ba7ac19929fb0e0c5d93f77827291f4da02b2232240fbc47ea7ce04c46e333e452f8656b667@34.65.107.0:30305",
+ "enode://c5d289b56a77b6a2342ca29956dfd07aadf45364dde8ab20d1dc4efd4d1bc6b4655d902501daea308f4d8950737a4e93a4dfedd17b49cd5760ffd127837ca965@34.65.202.239:30305",
+ // Base
+ "enode://87a32fd13bd596b2ffca97020e31aef4ddcc1bbd4b95bb633d16c1329f654f34049ed240a36b449fda5e5225d70fe40bc667f53c304b71f8e68fc9d448690b51@3.231.138.188:30301",
+ "enode://ca21ea8f176adb2e229ce2d700830c844af0ea941a1d8152a9513b966fe525e809c3a6c73a2c18a12b74ed6ec4380edf91662778fe0b79f6a591236e49e176f9@184.72.129.189:30301",
+ "enode://acf4507a211ba7c1e52cdf4eef62cdc3c32e7c9c47998954f7ba024026f9a6b2150cd3f0b734d9c78e507ab70d59ba61dfe5c45e1078c7ad0775fb251d7735a2@3.220.145.177:30301",
+ "enode://8a5a5006159bf079d06a04e5eceab2a1ce6e0f721875b2a9c96905336219dbe14203d38f70f3754686a6324f786c2f9852d8c0dd3adac2d080f4db35efc678c5@3.231.11.52:30301",
+ "enode://cdadbe835308ad3557f9a1de8db411da1a260a98f8421d62da90e71da66e55e98aaa8e90aa7ce01b408a54e4bd2253d701218081ded3dbe5efbbc7b41d7cef79@54.198.153.150:30301",
+}
+
+var V5OPTestnetBootnodes = []string{
+ // OP Labs
+ "enode://2bd2e657bb3c8efffb8ff6db9071d9eb7be70d7c6d7d980ff80fc93b2629675c5f750bc0a5ef27cd788c2e491b8795a7e9a4a6e72178c14acc6753c0e5d77ae4@34.65.205.244:30305",
+ "enode://db8e1cab24624cc62fc35dbb9e481b88a9ef0116114cd6e41034c55b5b4f18755983819252333509bd8e25f6b12aadd6465710cd2e956558faf17672cce7551f@34.65.173.88:30305",
+ "enode://bfda2e0110cfd0f4c9f7aa5bf5ec66e6bd18f71a2db028d36b8bf8b0d6fdb03125c1606a6017b31311d96a36f5ef7e1ad11604d7a166745e6075a715dfa67f8a@34.65.229.245:30305",
+ // Base
+ "enode://548f715f3fc388a7c917ba644a2f16270f1ede48a5d88a4d14ea287cc916068363f3092e39936f1a3e7885198bef0e5af951f1d7b1041ce8ba4010917777e71f@18.210.176.114:30301",
+ "enode://6f10052847a966a725c9f4adf6716f9141155b99a0fb487fea3f51498f4c2a2cb8d534e680ee678f9447db85b93ff7c74562762c3714783a7233ac448603b25f@107.21.251.55:30301",
}
const dnsPrefix = "enrtree://AKA3AM6LPBYEUDMVNU3BSVQJ5AD45Y7YPOHJLEF6W26QOE4VTUDPE@"
Generated TOML config update
+151
-85
diff --git go-ethereum/eth/ethconfig/gen_config.go op-geth/eth/ethconfig/gen_config.go
index 2abddc9e0d3878344f5ac547a0ac369db0d4a985..9ac514e9046e2070c2f1956bf481cacdab0c7512 100644
--- go-ethereum/eth/ethconfig/gen_config.go
+++ op-geth/eth/ethconfig/gen_config.go
@@ -5,57 +5,68 @@
import (
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/txpool/blobpool"
- "github.com/ethereum/go-ethereum/core/txpool/legacypool"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/gasprice"
- "github.com/ethereum/go-ethereum/miner"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/txpool/blobpool"
+ "github.com/tenderly/op-geth/core/txpool/legacypool"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/gasprice"
+ "github.com/tenderly/op-geth/miner"
)
// MarshalTOML marshals as TOML.
func (c Config) MarshalTOML() (interface{}, error) {
type Config struct {
- Genesis *core.Genesis `toml:",omitempty"`
- NetworkId uint64
- SyncMode downloader.SyncMode
- EthDiscoveryURLs []string
- SnapDiscoveryURLs []string
- NoPruning bool
- NoPrefetch bool
- TxLookupLimit uint64 `toml:",omitempty"`
- TransactionHistory uint64 `toml:",omitempty"`
- StateHistory uint64 `toml:",omitempty"`
- StateScheme string `toml:",omitempty"`
- RequiredBlocks map[uint64]common.Hash `toml:"-"`
- LightServ int `toml:",omitempty"`
- LightIngress int `toml:",omitempty"`
- LightEgress int `toml:",omitempty"`
- LightPeers int `toml:",omitempty"`
- LightNoPrune bool `toml:",omitempty"`
- LightNoSyncServe bool `toml:",omitempty"`
- SkipBcVersionCheck bool `toml:"-"`
- DatabaseHandles int `toml:"-"`
- DatabaseCache int
- DatabaseFreezer string
- TrieCleanCache int
- TrieDirtyCache int
- TrieTimeout time.Duration
- SnapshotCache int
- Preimages bool
- FilterLogCacheSize int
- Miner miner.Config
- TxPool legacypool.Config
- BlobPool blobpool.Config
- GPO gasprice.Config
- EnablePreimageRecording bool
- DocRoot string `toml:"-"`
- RPCGasCap uint64
- RPCEVMTimeout time.Duration
- RPCTxFeeCap float64
- OverrideCancun *uint64 `toml:",omitempty"`
- OverrideVerkle *uint64 `toml:",omitempty"`
+ Genesis *core.Genesis `toml:",omitempty"`
+ NetworkId uint64
+ SyncMode downloader.SyncMode
+ EthDiscoveryURLs []string
+ SnapDiscoveryURLs []string
+ NoPruning bool
+ NoPrefetch bool
+ TxLookupLimit uint64 `toml:",omitempty"`
+ TransactionHistory uint64 `toml:",omitempty"`
+ StateHistory uint64 `toml:",omitempty"`
+ StateScheme string `toml:",omitempty"`
+ RequiredBlocks map[uint64]common.Hash `toml:"-"`
+ LightServ int `toml:",omitempty"`
+ LightIngress int `toml:",omitempty"`
+ LightEgress int `toml:",omitempty"`
+ LightPeers int `toml:",omitempty"`
+ LightNoPrune bool `toml:",omitempty"`
+ LightNoSyncServe bool `toml:",omitempty"`
+ SkipBcVersionCheck bool `toml:"-"`
+ DatabaseHandles int `toml:"-"`
+ DatabaseCache int
+ DatabaseFreezer string
+ TrieCleanCache int
+ TrieDirtyCache int
+ TrieTimeout time.Duration
+ SnapshotCache int
+ Preimages bool
+ FilterLogCacheSize int
+ Miner miner.Config
+ TxPool legacypool.Config
+ BlobPool blobpool.Config
+ GPO gasprice.Config
+ EnablePreimageRecording bool
+ DocRoot string `toml:"-"`
+ RPCGasCap uint64
+ RPCEVMTimeout time.Duration
+ RPCTxFeeCap float64
+ OverrideCancun *uint64 `toml:",omitempty"`
+ OverrideVerkle *uint64 `toml:",omitempty"`
+ OverrideOptimismCanyon *uint64 `toml:",omitempty"`
+ OverrideOptimismEcotone *uint64 `toml:",omitempty"`
+ OverrideOptimismFjord *uint64 `toml:",omitempty"`
+ OverrideOptimismInterop *uint64 `toml:",omitempty"`
+ ApplySuperchainUpgrades bool `toml:",omitempty"`
+ RollupSequencerHTTP string
+ RollupHistoricalRPC string
+ RollupHistoricalRPCTimeout time.Duration
+ RollupDisableTxPoolGossip bool
+ RollupDisableTxPoolAdmission bool
+ RollupHaltOnIncompatibleProtocolVersion string
}
var enc Config
enc.Genesis = c.Genesis
@@ -97,51 +108,73 @@ enc.RPCEVMTimeout = c.RPCEVMTimeout
enc.RPCTxFeeCap = c.RPCTxFeeCap
enc.OverrideCancun = c.OverrideCancun
enc.OverrideVerkle = c.OverrideVerkle
+ enc.OverrideOptimismCanyon = c.OverrideOptimismCanyon
+ enc.OverrideOptimismEcotone = c.OverrideOptimismEcotone
+ enc.OverrideOptimismFjord = c.OverrideOptimismFjord
+ enc.OverrideOptimismInterop = c.OverrideOptimismInterop
+ enc.ApplySuperchainUpgrades = c.ApplySuperchainUpgrades
+ enc.RollupSequencerHTTP = c.RollupSequencerHTTP
+ enc.RollupHistoricalRPC = c.RollupHistoricalRPC
+ enc.RollupHistoricalRPCTimeout = c.RollupHistoricalRPCTimeout
+ enc.RollupDisableTxPoolGossip = c.RollupDisableTxPoolGossip
+ enc.RollupDisableTxPoolAdmission = c.RollupDisableTxPoolAdmission
+ enc.RollupHaltOnIncompatibleProtocolVersion = c.RollupHaltOnIncompatibleProtocolVersion
return &enc, nil
}
// UnmarshalTOML unmarshals from TOML.
func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
type Config struct {
- Genesis *core.Genesis `toml:",omitempty"`
- NetworkId *uint64
- SyncMode *downloader.SyncMode
- EthDiscoveryURLs []string
- SnapDiscoveryURLs []string
- NoPruning *bool
- NoPrefetch *bool
- TxLookupLimit *uint64 `toml:",omitempty"`
- TransactionHistory *uint64 `toml:",omitempty"`
- StateHistory *uint64 `toml:",omitempty"`
- StateScheme *string `toml:",omitempty"`
- RequiredBlocks map[uint64]common.Hash `toml:"-"`
- LightServ *int `toml:",omitempty"`
- LightIngress *int `toml:",omitempty"`
- LightEgress *int `toml:",omitempty"`
- LightPeers *int `toml:",omitempty"`
- LightNoPrune *bool `toml:",omitempty"`
- LightNoSyncServe *bool `toml:",omitempty"`
- SkipBcVersionCheck *bool `toml:"-"`
- DatabaseHandles *int `toml:"-"`
- DatabaseCache *int
- DatabaseFreezer *string
- TrieCleanCache *int
- TrieDirtyCache *int
- TrieTimeout *time.Duration
- SnapshotCache *int
- Preimages *bool
- FilterLogCacheSize *int
- Miner *miner.Config
- TxPool *legacypool.Config
- BlobPool *blobpool.Config
- GPO *gasprice.Config
- EnablePreimageRecording *bool
- DocRoot *string `toml:"-"`
- RPCGasCap *uint64
- RPCEVMTimeout *time.Duration
- RPCTxFeeCap *float64
- OverrideCancun *uint64 `toml:",omitempty"`
- OverrideVerkle *uint64 `toml:",omitempty"`
+ Genesis *core.Genesis `toml:",omitempty"`
+ NetworkId *uint64
+ SyncMode *downloader.SyncMode
+ EthDiscoveryURLs []string
+ SnapDiscoveryURLs []string
+ NoPruning *bool
+ NoPrefetch *bool
+ TxLookupLimit *uint64 `toml:",omitempty"`
+ TransactionHistory *uint64 `toml:",omitempty"`
+ StateHistory *uint64 `toml:",omitempty"`
+ StateScheme *string `toml:",omitempty"`
+ RequiredBlocks map[uint64]common.Hash `toml:"-"`
+ LightServ *int `toml:",omitempty"`
+ LightIngress *int `toml:",omitempty"`
+ LightEgress *int `toml:",omitempty"`
+ LightPeers *int `toml:",omitempty"`
+ LightNoPrune *bool `toml:",omitempty"`
+ LightNoSyncServe *bool `toml:",omitempty"`
+ SkipBcVersionCheck *bool `toml:"-"`
+ DatabaseHandles *int `toml:"-"`
+ DatabaseCache *int
+ DatabaseFreezer *string
+ TrieCleanCache *int
+ TrieDirtyCache *int
+ TrieTimeout *time.Duration
+ SnapshotCache *int
+ Preimages *bool
+ FilterLogCacheSize *int
+ Miner *miner.Config
+ TxPool *legacypool.Config
+ BlobPool *blobpool.Config
+ GPO *gasprice.Config
+ EnablePreimageRecording *bool
+ DocRoot *string `toml:"-"`
+ RPCGasCap *uint64
+ RPCEVMTimeout *time.Duration
+ RPCTxFeeCap *float64
+ OverrideCancun *uint64 `toml:",omitempty"`
+ OverrideVerkle *uint64 `toml:",omitempty"`
+ OverrideOptimismCanyon *uint64 `toml:",omitempty"`
+ OverrideOptimismEcotone *uint64 `toml:",omitempty"`
+ OverrideOptimismFjord *uint64 `toml:",omitempty"`
+ OverrideOptimismInterop *uint64 `toml:",omitempty"`
+ ApplySuperchainUpgrades *bool `toml:",omitempty"`
+ RollupSequencerHTTP *string
+ RollupHistoricalRPC *string
+ RollupHistoricalRPCTimeout *time.Duration
+ RollupDisableTxPoolGossip *bool
+ RollupDisableTxPoolAdmission *bool
+ RollupHaltOnIncompatibleProtocolVersion *string
}
var dec Config
if err := unmarshal(&dec); err != nil {
@@ -263,6 +296,39 @@ c.OverrideCancun = dec.OverrideCancun
}
if dec.OverrideVerkle != nil {
c.OverrideVerkle = dec.OverrideVerkle
+ }
+ if dec.OverrideOptimismCanyon != nil {
+ c.OverrideOptimismCanyon = dec.OverrideOptimismCanyon
+ }
+ if dec.OverrideOptimismEcotone != nil {
+ c.OverrideOptimismEcotone = dec.OverrideOptimismEcotone
+ }
+ if dec.OverrideOptimismFjord != nil {
+ c.OverrideOptimismFjord = dec.OverrideOptimismFjord
+ }
+ if dec.OverrideOptimismInterop != nil {
+ c.OverrideOptimismInterop = dec.OverrideOptimismInterop
+ }
+ if dec.ApplySuperchainUpgrades != nil {
+ c.ApplySuperchainUpgrades = *dec.ApplySuperchainUpgrades
+ }
+ if dec.RollupSequencerHTTP != nil {
+ c.RollupSequencerHTTP = *dec.RollupSequencerHTTP
+ }
+ if dec.RollupHistoricalRPC != nil {
+ c.RollupHistoricalRPC = *dec.RollupHistoricalRPC
+ }
+ if dec.RollupHistoricalRPCTimeout != nil {
+ c.RollupHistoricalRPCTimeout = *dec.RollupHistoricalRPCTimeout
+ }
+ if dec.RollupDisableTxPoolGossip != nil {
+ c.RollupDisableTxPoolGossip = *dec.RollupDisableTxPoolGossip
+ }
+ if dec.RollupDisableTxPoolAdmission != nil {
+ c.RollupDisableTxPoolAdmission = *dec.RollupDisableTxPoolAdmission
+ }
+ if dec.RollupHaltOnIncompatibleProtocolVersion != nil {
+ c.RollupHaltOnIncompatibleProtocolVersion = *dec.RollupHaltOnIncompatibleProtocolVersion
}
return nil
}
User API enhancements
+1077
-227
+409
-56
Encode the Deposit Tx properties, the L1 costs, and daisy-chain RPC-calls for pre-Bedrock historical data
Receipts metadata
+341
-52
Pre-Bedrock L1-cost receipt data is loaded from the database if available, and post-Bedrock the L1-cost metadata is hydrated on-the-fly based on the L1 fee information in the corresponding block.
diff --git go-ethereum/core/rawdb/accessors_chain.go op-geth/core/rawdb/accessors_chain.go
index 4686f82cf0970ae1b808c176055b46a310d19ed2..a88662d7f99ad66b36a450614f1fc0bdbbb75375 100644
--- go-ethereum/core/rawdb/accessors_chain.go
+++ op-geth/core/rawdb/accessors_chain.go
@@ -23,14 +23,14 @@ "errors"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/exp/slices"
)
@@ -626,7 +626,6 @@ log.Error("Missing body but have receipt", "hash", hash, "number", number)
return nil
}
header := ReadHeader(db, hash, number)
-
var baseFee *big.Int
if header == nil {
baseFee = big.NewInt(0)
@@ -676,6 +675,15 @@ type storedReceiptRLP struct {
PostStateOrStatus []byte
CumulativeGasUsed uint64
Logs []*types.Log
+
+ // Remaining fields are declared to allow the receipt RLP to be parsed without errors.
+ // However, they must not be used as they may not be populated correctly due to multiple receipt formats
+ // being combined into a single list of optional fields which can be mistaken for each other.
+ // DepositNonce (*uint64) from Regolith deposit tx receipts will be parsed into L1GasUsed
+ L1GasUsed *big.Int `rlp:"optional"` // OVM legacy
+ L1GasPrice *big.Int `rlp:"optional"` // OVM legacy
+ L1Fee *big.Int `rlp:"optional"` // OVM legacy
+ FeeScalar string `rlp:"optional"` // OVM legacy
}
// ReceiptLogs is a barebone version of ReceiptForStorage which only keeps
diff --git go-ethereum/core/types/gen_receipt_json.go op-geth/core/types/gen_receipt_json.go
index 4c641a972795f70ce27e98baf1b3c2e032fe89c2..9712ae3f4f648f9d8577cdfada144c578d8fa4fb 100644
--- go-ethereum/core/types/gen_receipt_json.go
+++ op-geth/core/types/gen_receipt_json.go
@@ -7,8 +7,8 @@ "encoding/json"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var _ = (*receiptMarshaling)(nil)
@@ -16,21 +16,30 @@
// MarshalJSON marshals as JSON.
func (r Receipt) MarshalJSON() ([]byte, error) {
type Receipt struct {
- Type hexutil.Uint64 `json:"type,omitempty"`
- PostState hexutil.Bytes `json:"root"`
- Status hexutil.Uint64 `json:"status"`
- CumulativeGasUsed hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
- Bloom Bloom `json:"logsBloom" gencodec:"required"`
- Logs []*Log `json:"logs" gencodec:"required"`
- TxHash common.Hash `json:"transactionHash" gencodec:"required"`
- ContractAddress common.Address `json:"contractAddress"`
- GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"`
- EffectiveGasPrice *hexutil.Big `json:"effectiveGasPrice"`
- BlobGasUsed hexutil.Uint64 `json:"blobGasUsed,omitempty"`
- BlobGasPrice *hexutil.Big `json:"blobGasPrice,omitempty"`
- BlockHash common.Hash `json:"blockHash,omitempty"`
- BlockNumber *hexutil.Big `json:"blockNumber,omitempty"`
- TransactionIndex hexutil.Uint `json:"transactionIndex"`
+ Type hexutil.Uint64 `json:"type,omitempty"`
+ PostState hexutil.Bytes `json:"root"`
+ Status hexutil.Uint64 `json:"status"`
+ CumulativeGasUsed hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
+ Bloom Bloom `json:"logsBloom" gencodec:"required"`
+ Logs []*Log `json:"logs" gencodec:"required"`
+ TxHash common.Hash `json:"transactionHash" gencodec:"required"`
+ ContractAddress common.Address `json:"contractAddress"`
+ GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"`
+ EffectiveGasPrice *hexutil.Big `json:"effectiveGasPrice"`
+ BlobGasUsed hexutil.Uint64 `json:"blobGasUsed,omitempty"`
+ BlobGasPrice *hexutil.Big `json:"blobGasPrice,omitempty"`
+ DepositNonce *hexutil.Uint64 `json:"depositNonce,omitempty"`
+ DepositReceiptVersion *hexutil.Uint64 `json:"depositReceiptVersion,omitempty"`
+ BlockHash common.Hash `json:"blockHash,omitempty"`
+ BlockNumber *hexutil.Big `json:"blockNumber,omitempty"`
+ TransactionIndex hexutil.Uint `json:"transactionIndex"`
+ L1GasPrice *hexutil.Big `json:"l1GasPrice,omitempty"`
+ L1BlobBaseFee *hexutil.Big `json:"l1BlobBaseFee,omitempty"`
+ L1GasUsed *hexutil.Big `json:"l1GasUsed,omitempty"`
+ L1Fee *hexutil.Big `json:"l1Fee,omitempty"`
+ FeeScalar *big.Float `json:"l1FeeScalar,omitempty"`
+ L1BaseFeeScalar *hexutil.Uint64 `json:"l1BaseFeeScalar,omitempty"`
+ L1BlobBaseFeeScalar *hexutil.Uint64 `json:"l1BlobBaseFeeScalar,omitempty"`
}
var enc Receipt
enc.Type = hexutil.Uint64(r.Type)
@@ -45,30 +54,48 @@ enc.GasUsed = hexutil.Uint64(r.GasUsed)
enc.EffectiveGasPrice = (*hexutil.Big)(r.EffectiveGasPrice)
enc.BlobGasUsed = hexutil.Uint64(r.BlobGasUsed)
enc.BlobGasPrice = (*hexutil.Big)(r.BlobGasPrice)
+ enc.DepositNonce = (*hexutil.Uint64)(r.DepositNonce)
+ enc.DepositReceiptVersion = (*hexutil.Uint64)(r.DepositReceiptVersion)
enc.BlockHash = r.BlockHash
enc.BlockNumber = (*hexutil.Big)(r.BlockNumber)
enc.TransactionIndex = hexutil.Uint(r.TransactionIndex)
+ enc.L1GasPrice = (*hexutil.Big)(r.L1GasPrice)
+ enc.L1BlobBaseFee = (*hexutil.Big)(r.L1BlobBaseFee)
+ enc.L1GasUsed = (*hexutil.Big)(r.L1GasUsed)
+ enc.L1Fee = (*hexutil.Big)(r.L1Fee)
+ enc.FeeScalar = r.FeeScalar
+ enc.L1BaseFeeScalar = (*hexutil.Uint64)(r.L1BaseFeeScalar)
+ enc.L1BlobBaseFeeScalar = (*hexutil.Uint64)(r.L1BlobBaseFeeScalar)
return json.Marshal(&enc)
}
// UnmarshalJSON unmarshals from JSON.
func (r *Receipt) UnmarshalJSON(input []byte) error {
type Receipt struct {
- Type *hexutil.Uint64 `json:"type,omitempty"`
- PostState *hexutil.Bytes `json:"root"`
- Status *hexutil.Uint64 `json:"status"`
- CumulativeGasUsed *hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
- Bloom *Bloom `json:"logsBloom" gencodec:"required"`
- Logs []*Log `json:"logs" gencodec:"required"`
- TxHash *common.Hash `json:"transactionHash" gencodec:"required"`
- ContractAddress *common.Address `json:"contractAddress"`
- GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"`
- EffectiveGasPrice *hexutil.Big `json:"effectiveGasPrice"`
- BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed,omitempty"`
- BlobGasPrice *hexutil.Big `json:"blobGasPrice,omitempty"`
- BlockHash *common.Hash `json:"blockHash,omitempty"`
- BlockNumber *hexutil.Big `json:"blockNumber,omitempty"`
- TransactionIndex *hexutil.Uint `json:"transactionIndex"`
+ Type *hexutil.Uint64 `json:"type,omitempty"`
+ PostState *hexutil.Bytes `json:"root"`
+ Status *hexutil.Uint64 `json:"status"`
+ CumulativeGasUsed *hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
+ Bloom *Bloom `json:"logsBloom" gencodec:"required"`
+ Logs []*Log `json:"logs" gencodec:"required"`
+ TxHash *common.Hash `json:"transactionHash" gencodec:"required"`
+ ContractAddress *common.Address `json:"contractAddress"`
+ GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"`
+ EffectiveGasPrice *hexutil.Big `json:"effectiveGasPrice"`
+ BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed,omitempty"`
+ BlobGasPrice *hexutil.Big `json:"blobGasPrice,omitempty"`
+ DepositNonce *hexutil.Uint64 `json:"depositNonce,omitempty"`
+ DepositReceiptVersion *hexutil.Uint64 `json:"depositReceiptVersion,omitempty"`
+ BlockHash *common.Hash `json:"blockHash,omitempty"`
+ BlockNumber *hexutil.Big `json:"blockNumber,omitempty"`
+ TransactionIndex *hexutil.Uint `json:"transactionIndex"`
+ L1GasPrice *hexutil.Big `json:"l1GasPrice,omitempty"`
+ L1BlobBaseFee *hexutil.Big `json:"l1BlobBaseFee,omitempty"`
+ L1GasUsed *hexutil.Big `json:"l1GasUsed,omitempty"`
+ L1Fee *hexutil.Big `json:"l1Fee,omitempty"`
+ FeeScalar *big.Float `json:"l1FeeScalar,omitempty"`
+ L1BaseFeeScalar *hexutil.Uint64 `json:"l1BaseFeeScalar,omitempty"`
+ L1BlobBaseFeeScalar *hexutil.Uint64 `json:"l1BlobBaseFeeScalar,omitempty"`
}
var dec Receipt
if err := json.Unmarshal(input, &dec); err != nil {
@@ -115,6 +142,12 @@ }
if dec.BlobGasPrice != nil {
r.BlobGasPrice = (*big.Int)(dec.BlobGasPrice)
}
+ if dec.DepositNonce != nil {
+ r.DepositNonce = (*uint64)(dec.DepositNonce)
+ }
+ if dec.DepositReceiptVersion != nil {
+ r.DepositReceiptVersion = (*uint64)(dec.DepositReceiptVersion)
+ }
if dec.BlockHash != nil {
r.BlockHash = *dec.BlockHash
}
@@ -123,6 +156,27 @@ r.BlockNumber = (*big.Int)(dec.BlockNumber)
}
if dec.TransactionIndex != nil {
r.TransactionIndex = uint(*dec.TransactionIndex)
+ }
+ if dec.L1GasPrice != nil {
+ r.L1GasPrice = (*big.Int)(dec.L1GasPrice)
+ }
+ if dec.L1BlobBaseFee != nil {
+ r.L1BlobBaseFee = (*big.Int)(dec.L1BlobBaseFee)
+ }
+ if dec.L1GasUsed != nil {
+ r.L1GasUsed = (*big.Int)(dec.L1GasUsed)
+ }
+ if dec.L1Fee != nil {
+ r.L1Fee = (*big.Int)(dec.L1Fee)
+ }
+ if dec.FeeScalar != nil {
+ r.FeeScalar = dec.FeeScalar
+ }
+ if dec.L1BaseFeeScalar != nil {
+ r.L1BaseFeeScalar = (*uint64)(dec.L1BaseFeeScalar)
+ }
+ if dec.L1BlobBaseFeeScalar != nil {
+ r.L1BlobBaseFeeScalar = (*uint64)(dec.L1BlobBaseFeeScalar)
}
return nil
}
diff --git go-ethereum/core/types/receipt.go op-geth/core/types/receipt.go
index 4f96fde59c44278beee06e9846e158c2501644e6..77faa7033d4c2c21a0e4c48e9cf1a809de2742db 100644
--- go-ethereum/core/types/receipt.go
+++ op-geth/core/types/receipt.go
@@ -24,11 +24,11 @@ "io"
"math/big"
"unsafe"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
//go:generate go run github.com/fjl/gencodec -type Receipt -field-override receiptMarshaling -out gen_receipt_json.go
@@ -46,6 +46,9 @@ ReceiptStatusFailed = uint64(0)
// ReceiptStatusSuccessful is the status code of a transaction if execution succeeded.
ReceiptStatusSuccessful = uint64(1)
+
+ // The version number for post-canyon deposit receipts.
+ CanyonDepositReceiptVersion = uint64(1)
)
// Receipt represents the results of a transaction.
@@ -58,7 +61,8 @@ CumulativeGasUsed uint64 `json:"cumulativeGasUsed" gencodec:"required"`
Bloom Bloom `json:"logsBloom" gencodec:"required"`
Logs []*Log `json:"logs" gencodec:"required"`
- // Implementation fields: These fields are added by geth when processing a transaction.
+ // Implementation fields: These fields are added by geth when processing a transaction or retrieving a receipt.
+ // gencodec annotated fields: these are stored in the chain database.
TxHash common.Hash `json:"transactionHash" gencodec:"required"`
ContractAddress common.Address `json:"contractAddress"`
GasUsed uint64 `json:"gasUsed" gencodec:"required"`
@@ -66,11 +70,28 @@ EffectiveGasPrice *big.Int `json:"effectiveGasPrice"` // required, but tag omitted for backwards compatibility
BlobGasUsed uint64 `json:"blobGasUsed,omitempty"`
BlobGasPrice *big.Int `json:"blobGasPrice,omitempty"`
+ // DepositNonce was introduced in Regolith to store the actual nonce used by deposit transactions
+ // The state transition process ensures this is only set for Regolith deposit transactions.
+ DepositNonce *uint64 `json:"depositNonce,omitempty"`
+ // DepositReceiptVersion was introduced in Canyon to indicate an update to how receipt hashes
+ // should be computed when set. The state transition process ensures this is only set for
+ // post-Canyon deposit transactions.
+ DepositReceiptVersion *uint64 `json:"depositReceiptVersion,omitempty"`
+
// Inclusion information: These fields provide information about the inclusion of the
// transaction corresponding to this receipt.
BlockHash common.Hash `json:"blockHash,omitempty"`
BlockNumber *big.Int `json:"blockNumber,omitempty"`
TransactionIndex uint `json:"transactionIndex"`
+
+ // Optimism: extend receipts with L1 fee info
+ L1GasPrice *big.Int `json:"l1GasPrice,omitempty"` // Present from pre-bedrock. L1 Basefee after Bedrock
+ L1BlobBaseFee *big.Int `json:"l1BlobBaseFee,omitempty"` // Always nil prior to the Ecotone hardfork
+ L1GasUsed *big.Int `json:"l1GasUsed,omitempty"` // Present from pre-bedrock, deprecated as of Fjord
+ L1Fee *big.Int `json:"l1Fee,omitempty"` // Present from pre-bedrock
+ FeeScalar *big.Float `json:"l1FeeScalar,omitempty"` // Present from pre-bedrock to Ecotone. Nil after Ecotone
+ L1BaseFeeScalar *uint64 `json:"l1BaseFeeScalar,omitempty"` // Always nil prior to the Ecotone hardfork
+ L1BlobBaseFeeScalar *uint64 `json:"l1BlobBaseFeeScalar,omitempty"` // Always nil prior to the Ecotone hardfork
}
type receiptMarshaling struct {
@@ -84,6 +105,17 @@ BlobGasUsed hexutil.Uint64
BlobGasPrice *hexutil.Big
BlockNumber *hexutil.Big
TransactionIndex hexutil.Uint
+
+ // Optimism
+ L1GasPrice *hexutil.Big
+ L1BlobBaseFee *hexutil.Big
+ L1GasUsed *hexutil.Big
+ L1Fee *hexutil.Big
+ FeeScalar *big.Float
+ L1BaseFeeScalar *hexutil.Uint64
+ L1BlobBaseFeeScalar *hexutil.Uint64
+ DepositNonce *hexutil.Uint64
+ DepositReceiptVersion *hexutil.Uint64
}
// receiptRLP is the consensus encoding of a receipt.
@@ -94,11 +126,98 @@ Bloom Bloom
Logs []*Log
}
+type depositReceiptRLP struct {
+ PostStateOrStatus []byte
+ CumulativeGasUsed uint64
+ Bloom Bloom
+ Logs []*Log
+ // DepositNonce was introduced in Regolith to store the actual nonce used by deposit transactions.
+ // Must be nil for any transactions prior to Regolith or that aren't deposit transactions.
+ DepositNonce *uint64 `rlp:"optional"`
+ // Receipt hash post-Regolith but pre-Canyon inadvertently did not include the above
+ // DepositNonce. Post Canyon, receipts will have a non-empty DepositReceiptVersion indicating
+ // which post-Canyon receipt hash function to invoke.
+ DepositReceiptVersion *uint64 `rlp:"optional"`
+}
+
// storedReceiptRLP is the storage encoding of a receipt.
type storedReceiptRLP struct {
PostStateOrStatus []byte
CumulativeGasUsed uint64
Logs []*Log
+ // DepositNonce was introduced in Regolith to store the actual nonce used by deposit transactions.
+ // Must be nil for any transactions prior to Regolith or that aren't deposit transactions.
+ DepositNonce *uint64 `rlp:"optional"`
+ // Receipt hash post-Regolith but pre-Canyon inadvertently did not include the above
+ // DepositNonce. Post Canyon, receipts will have a non-empty DepositReceiptVersion indicating
+ // which post-Canyon receipt hash function to invoke.
+ DepositReceiptVersion *uint64 `rlp:"optional"`
+}
+
+// LegacyOptimismStoredReceiptRLP is the pre bedrock storage encoding of a
+// receipt. It will only exist in the database if it was migrated using the
+// migration tool. Nodes that sync using snap-sync will not have any of these
+// entries.
+type LegacyOptimismStoredReceiptRLP struct {
+ PostStateOrStatus []byte
+ CumulativeGasUsed uint64
+ Logs []*LogForStorage
+ L1GasUsed *big.Int
+ L1GasPrice *big.Int
+ L1Fee *big.Int
+ FeeScalar string
+}
+
+// LogForStorage is a wrapper around a Log that handles
+// backward compatibility with prior storage formats.
+type LogForStorage Log
+
+// EncodeRLP implements rlp.Encoder.
+func (l *LogForStorage) EncodeRLP(w io.Writer) error {
+ rl := Log{Address: l.Address, Topics: l.Topics, Data: l.Data}
+ return rlp.Encode(w, &rl)
+}
+
+type legacyRlpStorageLog struct {
+ Address common.Address
+ Topics []common.Hash
+ Data []byte
+ BlockNumber uint64
+ TxHash common.Hash
+ TxIndex uint
+ BlockHash common.Hash
+ Index uint
+}
+
+// DecodeRLP implements rlp.Decoder.
+//
+// Note some redundant fields(e.g. block number, tx hash etc) will be assembled later.
+func (l *LogForStorage) DecodeRLP(s *rlp.Stream) error {
+ blob, err := s.Raw()
+ if err != nil {
+ return err
+ }
+ var dec Log
+ err = rlp.DecodeBytes(blob, &dec)
+ if err == nil {
+ *l = LogForStorage{
+ Address: dec.Address,
+ Topics: dec.Topics,
+ Data: dec.Data,
+ }
+ } else {
+ // Try to decode log with previous definition.
+ var dec legacyRlpStorageLog
+ err = rlp.DecodeBytes(blob, &dec)
+ if err == nil {
+ *l = LogForStorage{
+ Address: dec.Address,
+ Topics: dec.Topics,
+ Data: dec.Data,
+ }
+ }
+ }
+ return err
}
// NewReceipt creates a barebone transaction receipt, copying the init fields.
@@ -136,7 +255,13 @@
// encodeTyped writes the canonical encoding of a typed receipt to w.
func (r *Receipt) encodeTyped(data *receiptRLP, w *bytes.Buffer) error {
w.WriteByte(r.Type)
- return rlp.Encode(w, data)
+ switch r.Type {
+ case DepositTxType:
+ withNonce := &depositReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs, r.DepositNonce, r.DepositReceiptVersion}
+ return rlp.Encode(w, withNonce)
+ default:
+ return rlp.Encode(w, data)
+ }
}
// MarshalBinary returns the consensus encoding of the receipt.
@@ -212,6 +337,16 @@ return err
}
r.Type = b[0]
return r.setFromRLP(data)
+ case DepositTxType:
+ var data depositReceiptRLP
+ err := rlp.DecodeBytes(b[1:], &data)
+ if err != nil {
+ return err
+ }
+ r.Type = b[0]
+ r.DepositNonce = data.DepositNonce
+ r.DepositReceiptVersion = data.DepositReceiptVersion
+ return r.setFromRLP(receiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs})
default:
return ErrTxTypeNotSupported
}
@@ -275,6 +410,12 @@ return err
}
}
w.ListEnd(logList)
+ if r.DepositNonce != nil {
+ w.WriteUint64(*r.DepositNonce)
+ if r.DepositReceiptVersion != nil {
+ w.WriteUint64(*r.DepositReceiptVersion)
+ }
+ }
w.ListEnd(outerList)
return w.Flush()
}
@@ -282,8 +423,51 @@
// DecodeRLP implements rlp.Decoder, and loads both consensus and implementation
// fields of a receipt from an RLP stream.
func (r *ReceiptForStorage) DecodeRLP(s *rlp.Stream) error {
+ // Retrieve the entire receipt blob as we need to try multiple decoders
+ blob, err := s.Raw()
+ if err != nil {
+ return err
+ }
+ // First try to decode the latest receipt database format, try the pre-bedrock Optimism legacy format otherwise.
+ if err := decodeStoredReceiptRLP(r, blob); err == nil {
+ return nil
+ }
+ return decodeLegacyOptimismReceiptRLP(r, blob)
+}
+
+func decodeLegacyOptimismReceiptRLP(r *ReceiptForStorage, blob []byte) error {
+ var stored LegacyOptimismStoredReceiptRLP
+ if err := rlp.DecodeBytes(blob, &stored); err != nil {
+ return err
+ }
+ if err := (*Receipt)(r).setStatus(stored.PostStateOrStatus); err != nil {
+ return err
+ }
+ r.CumulativeGasUsed = stored.CumulativeGasUsed
+ r.Logs = make([]*Log, len(stored.Logs))
+ for i, log := range stored.Logs {
+ r.Logs[i] = (*Log)(log)
+ }
+ r.Bloom = CreateBloom(Receipts{(*Receipt)(r)})
+ // UsingOVM
+ scalar := new(big.Float)
+ if stored.FeeScalar != "" {
+ var ok bool
+ scalar, ok = scalar.SetString(stored.FeeScalar)
+ if !ok {
+ return errors.New("cannot parse fee scalar")
+ }
+ }
+ r.L1GasUsed = stored.L1GasUsed
+ r.L1GasPrice = stored.L1GasPrice
+ r.L1Fee = stored.L1Fee
+ r.FeeScalar = scalar
+ return nil
+}
+
+func decodeStoredReceiptRLP(r *ReceiptForStorage, blob []byte) error {
var stored storedReceiptRLP
- if err := s.Decode(&stored); err != nil {
+ if err := rlp.DecodeBytes(blob, &stored); err != nil {
return err
}
if err := (*Receipt)(r).setStatus(stored.PostStateOrStatus); err != nil {
@@ -292,7 +476,10 @@ }
r.CumulativeGasUsed = stored.CumulativeGasUsed
r.Logs = stored.Logs
r.Bloom = CreateBloom(Receipts{(*Receipt)(r)})
-
+ if stored.DepositNonce != nil {
+ r.DepositNonce = stored.DepositNonce
+ r.DepositReceiptVersion = stored.DepositReceiptVersion
+ }
return nil
}
@@ -302,7 +489,10 @@
// Len returns the number of receipts in this list.
func (rs Receipts) Len() int { return len(rs) }
-// EncodeIndex encodes the i'th receipt to w.
+// EncodeIndex encodes the i'th receipt to w. For DepositTxType receipts with non-nil DepositNonce
+// but nil DepositReceiptVersion, the output will differ than calling r.MarshalBinary(); this
+// behavior difference should not be changed to preserve backwards compatibility of receipt-root
+// hash computation.
func (rs Receipts) EncodeIndex(i int, w *bytes.Buffer) {
r := rs[i]
data := &receiptRLP{r.statusEncoding(), r.CumulativeGasUsed, r.Bloom, r.Logs}
@@ -314,6 +504,14 @@ w.WriteByte(r.Type)
switch r.Type {
case AccessListTxType, DynamicFeeTxType, BlobTxType:
rlp.Encode(w, data)
+ case DepositTxType:
+ if r.DepositReceiptVersion != nil {
+ // post-canyon receipt hash computation update
+ depositData := &depositReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, r.Bloom, r.Logs, r.DepositNonce, r.DepositReceiptVersion}
+ rlp.Encode(w, depositData)
+ } else {
+ rlp.Encode(w, data)
+ }
default:
// For unsupported types, write nothing. Since this is for
// DeriveSha, the error will be caught matching the derived hash
@@ -351,7 +549,11 @@ // The contract address can be derived from the transaction itself
if txs[i].To() == nil {
// Deriving the signer is expensive, only do if it's actually needed
from, _ := Sender(signer, txs[i])
- rs[i].ContractAddress = crypto.CreateAddress(from, txs[i].Nonce())
+ nonce := txs[i].Nonce()
+ if rs[i].DepositNonce != nil {
+ nonce = *rs[i].DepositNonce
+ }
+ rs[i].ContractAddress = crypto.CreateAddress(from, nonce)
} else {
rs[i].ContractAddress = common.Address{}
}
@@ -373,5 +575,30 @@ rs[i].Logs[j].Index = logIndex
logIndex++
}
}
+ if config.Optimism != nil && len(txs) >= 2 && config.IsBedrock(new(big.Int).SetUint64(number)) { // need at least an info tx and a non-info tx
+ gasParams, err := extractL1GasParams(config, time, txs[0].Data())
+ if err != nil {
+ return err
+ }
+ for i := 0; i < len(rs); i++ {
+ if txs[i].IsDepositTx() {
+ continue
+ }
+ rs[i].L1GasPrice = gasParams.l1BaseFee
+ rs[i].L1BlobBaseFee = gasParams.l1BlobBaseFee
+ rs[i].L1Fee, rs[i].L1GasUsed = gasParams.costFunc(txs[i].RollupCostData())
+ rs[i].FeeScalar = gasParams.feeScalar
+ rs[i].L1BaseFeeScalar = u32ptrTou64ptr(gasParams.l1BaseFeeScalar)
+ rs[i].L1BlobBaseFeeScalar = u32ptrTou64ptr(gasParams.l1BlobBaseFeeScalar)
+ }
+ }
return nil
}
+
+func u32ptrTou64ptr(a *uint32) *uint64 {
+ if a == nil {
+ return nil
+ }
+ b := uint64(*a)
+ return &b
+}
API Backend
+205
-76
Forward transactions to the sequencer if configured.
diff --git go-ethereum/eth/api_backend.go op-geth/eth/api_backend.go
index 65adccd8518cd6faee0c0a0898d44602ba2ce8ec..b7becfc569353a7c831a65b2176a6e9e5e861b6f 100644
--- go-ethereum/eth/api_backend.go
+++ op-geth/eth/api_backend.go
@@ -19,33 +19,37 @@
import (
"context"
"errors"
+ "fmt"
"math/big"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/bloombits"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/gasprice"
- "github.com/ethereum/go-ethereum/eth/tracers"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/miner"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/bloombits"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/gasprice"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/miner"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
// EthAPIBackend implements ethapi.Backend and tracers.Backend for full nodes
type EthAPIBackend struct {
extRPCEnabled bool
allowUnprotectedTxs bool
+ disableTxPool bool
eth *Ethereum
gpo *gasprice.Oracle
}
@@ -190,10 +194,11 @@ func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
// Pending state is only known by the miner
if number == rpc.PendingBlockNumber {
block, state := b.eth.miner.Pending()
- if block == nil || state == nil {
- return nil, nil, errors.New("pending state is not available")
+ if block != nil && state != nil {
+ return state, block.Header(), nil
+ } else {
+ number = rpc.LatestBlockNumber // fall back to latest state
}
- return state, block.Header(), nil
}
// Otherwise resolve the block number and return its state
header, err := b.HeaderByNumber(ctx, number)
@@ -201,7 +206,7 @@ if err != nil {
return nil, nil, err
}
if header == nil {
- return nil, nil, errors.New("header not found")
+ return nil, nil, fmt.Errorf("header %w", ethereum.NotFound)
}
stateDb, err := b.eth.BlockChain().StateAt(header.Root)
if err != nil {
@@ -220,7 +225,7 @@ if err != nil {
return nil, nil, err
}
if header == nil {
- return nil, nil, errors.New("header for hash not found")
+ return nil, nil, fmt.Errorf("header for hash %w", ethereum.NotFound)
}
if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(header.Number.Uint64()) != hash {
return nil, nil, errors.New("hash is not currently canonical")
@@ -258,7 +263,7 @@ var context vm.BlockContext
if blockCtx != nil {
context = *blockCtx
} else {
- context = core.NewEVMBlockContext(header, b.eth.BlockChain(), nil)
+ context = core.NewEVMBlockContext(header, b.eth.BlockChain(), nil, b.eth.blockchain.Config(), state)
}
return vm.NewEVM(context, txContext, state, b.ChainConfig(), *vmConfig)
}
@@ -288,6 +293,29 @@ return b.eth.BlockChain().SubscribeLogsEvent(ch)
}
func (b *EthAPIBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
+ if b.ChainConfig().IsOptimism() && signedTx.Type() == types.BlobTxType {
+ return types.ErrTxTypeNotSupported
+ }
+ if b.eth.seqRPCService != nil {
+ data, err := signedTx.MarshalBinary()
+ if err != nil {
+ return err
+ }
+ if err := b.eth.seqRPCService.CallContext(ctx, nil, "eth_sendRawTransaction", hexutil.Encode(data)); err != nil {
+ return err
+ }
+ if b.disableTxPool {
+ return nil
+ }
+ // Retain tx in local tx pool after forwarding, for local RPC usage.
+ if err := b.eth.txPool.Add([]*types.Transaction{signedTx}, true, false)[0]; err != nil {
+ log.Warn("successfully sent tx to sequencer, but failed to persist in local tx pool", "err", err, "tx", signedTx.Hash())
+ }
+ return nil
+ }
+ if b.disableTxPool {
+ return nil
+ }
return b.eth.txPool.Add([]*types.Transaction{signedTx}, true, false)[0]
}
@@ -436,3 +464,11 @@
func (b *EthAPIBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) {
return b.eth.stateAtTransaction(ctx, block, txIndex, reexec)
}
+
+func (b *EthAPIBackend) HistoricalRPCService() *rpc.Client {
+ return b.eth.historicalRPCService
+}
+
+func (b *EthAPIBackend) Genesis() *types.Block {
+ return b.eth.blockchain.Genesis()
+}
diff --git go-ethereum/eth/backend.go op-geth/eth/backend.go
index 0a0813aafac6a73f95cca62b8ca9f4587dae9377..f60585159810d3512a0671a0a7dcd1ef2c6146e7 100644
--- go-ethereum/eth/backend.go
+++ op-geth/eth/backend.go
@@ -18,45 +18,47 @@ // Package eth implements the Ethereum protocol.
package eth
import (
+ "context"
"errors"
"fmt"
"math/big"
"runtime"
"sync"
+ "time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/consensus/clique"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/bloombits"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state/pruner"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/txpool/blobpool"
- "github.com/ethereum/go-ethereum/core/txpool/legacypool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/eth/gasprice"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/eth/protocols/snap"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/internal/shutdowncheck"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/miner"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/dnsdisc"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/consensus/clique"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/bloombits"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state/pruner"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/txpool/blobpool"
+ "github.com/tenderly/op-geth/core/txpool/legacypool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/eth/gasprice"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/eth/protocols/snap"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/internal/shutdowncheck"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/miner"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/dnsdisc"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/rpc"
)
// Config contains the configuration options of the ETH protocol.
@@ -75,6 +77,9 @@ handler *handler
ethDialCandidates enode.Iterator
snapDialCandidates enode.Iterator
merger *consensus.Merger
+
+ seqRPCService *rpc.Client
+ historicalRPCService *rpc.Client
// DB interfaces
chainDb ethdb.Database // Block chain database
@@ -101,6 +106,8 @@
lock sync.RWMutex // Protects the variadic fields (e.g. gas price and etherbase)
shutdownTracker *shutdowncheck.ShutdownTracker // Tracks if and when the node has shutdown ungracefully
+
+ nodeCloser func() error
}
// New creates a new Ethereum object (including the
@@ -171,13 +178,13 @@ bloomRequests: make(chan chan *bloombits.Retrieval),
bloomIndexer: core.NewBloomIndexer(chainDb, params.BloomBitsBlocks, params.BloomConfirms),
p2pServer: stack.Server(),
shutdownTracker: shutdowncheck.NewShutdownTracker(chainDb),
+ nodeCloser: stack.Close,
}
bcVersion := rawdb.ReadDatabaseVersion(chainDb)
- var dbVer = "<nil>"
+ dbVer := "<nil>"
if bcVersion != nil {
dbVer = fmt.Sprintf("%d", *bcVersion)
}
- log.Info("Initialising Ethereum protocol", "network", networkID, "dbversion", dbVer)
if !config.SkipBcVersionCheck {
if bcVersion != nil && *bcVersion > core.BlockChainVersion {
@@ -213,23 +220,50 @@ }
if config.OverrideVerkle != nil {
overrides.OverrideVerkle = config.OverrideVerkle
}
+ if config.OverrideOptimismCanyon != nil {
+ overrides.OverrideOptimismCanyon = config.OverrideOptimismCanyon
+ }
+ if config.OverrideOptimismEcotone != nil {
+ overrides.OverrideOptimismEcotone = config.OverrideOptimismEcotone
+ }
+ if config.OverrideOptimismFjord != nil {
+ overrides.OverrideOptimismFjord = config.OverrideOptimismFjord
+ }
+ if config.OverrideOptimismInterop != nil {
+ overrides.OverrideOptimismInterop = config.OverrideOptimismInterop
+ }
+ overrides.ApplySuperchainUpgrades = config.ApplySuperchainUpgrades
eth.blockchain, err = core.NewBlockChain(chainDb, cacheConfig, config.Genesis, &overrides, eth.engine, vmConfig, eth.shouldPreserve, &config.TransactionHistory)
if err != nil {
return nil, err
}
+ if chainConfig := eth.blockchain.Config(); chainConfig.Optimism != nil { // config.Genesis.Config.ChainID cannot be used because it's based on CLI flags only, thus default to mainnet L1
+ config.NetworkId = chainConfig.ChainID.Uint64() // optimism defaults eth network ID to chain ID
+ eth.networkID = config.NetworkId
+ }
+ log.Info("Initialising Ethereum protocol", "network", config.NetworkId, "dbversion", dbVer)
+
+ if eth.blockchain.Config().Optimism != nil { // Optimism Bedrock depends on Merge functionality
+ eth.merger.FinalizePoS()
+ }
+
eth.bloomIndexer.Start(eth.blockchain)
if config.BlobPool.Datadir != "" {
config.BlobPool.Datadir = stack.ResolvePath(config.BlobPool.Datadir)
}
- blobPool := blobpool.New(config.BlobPool, eth.blockchain)
if config.TxPool.Journal != "" {
config.TxPool.Journal = stack.ResolvePath(config.TxPool.Journal)
}
legacyPool := legacypool.New(config.TxPool, eth.blockchain)
- eth.txPool, err = txpool.New(config.TxPool.PriceLimit, eth.blockchain, []txpool.SubPool{legacyPool, blobPool})
+ txPools := []txpool.SubPool{legacyPool}
+ if !eth.BlockChain().Config().IsOptimism() {
+ blobPool := blobpool.New(config.BlobPool, eth.blockchain)
+ txPools = append(txPools, blobPool)
+ }
+ eth.txPool, err = txpool.New(config.TxPool.PriceLimit, eth.blockchain, txPools)
if err != nil {
return nil, err
}
@@ -245,6 +279,7 @@ Sync: config.SyncMode,
BloomCache: uint64(cacheLimit),
EventMux: eth.eventMux,
RequiredBlocks: config.RequiredBlocks,
+ NoTxGossip: config.RollupDisableTxPoolGossip,
}); err != nil {
return nil, err
}
@@ -252,7 +287,7 @@
eth.miner = miner.New(eth, &config.Miner, eth.blockchain.Config(), eth.EventMux(), eth.engine, eth.isLocalBlock)
eth.miner.SetExtra(makeExtraData(config.Miner.ExtraData))
- eth.APIBackend = &EthAPIBackend{stack.Config().ExtRPCEnabled(), stack.Config().AllowUnprotectedTxs, eth, nil}
+ eth.APIBackend = &EthAPIBackend{stack.Config().ExtRPCEnabled(), stack.Config().AllowUnprotectedTxs, config.RollupDisableTxPoolAdmission, eth, nil}
if eth.APIBackend.allowUnprotectedTxs {
log.Info("Unprotected transactions allowed")
}
@@ -273,6 +308,26 @@ if err != nil {
return nil, err
}
+ if config.RollupSequencerHTTP != "" {
+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ client, err := rpc.DialContext(ctx, config.RollupSequencerHTTP)
+ cancel()
+ if err != nil {
+ return nil, err
+ }
+ eth.seqRPCService = client
+ }
+
+ if config.RollupHistoricalRPC != "" {
+ ctx, cancel := context.WithTimeout(context.Background(), config.RollupHistoricalRPCTimeout)
+ client, err := rpc.DialContext(ctx, config.RollupHistoricalRPC)
+ cancel()
+ if err != nil {
+ return nil, err
+ }
+ eth.historicalRPCService = client
+ }
+
// Start the RPC service
eth.netRPCService = ethapi.NewNetAPI(eth.p2pServer, networkID)
@@ -291,7 +346,7 @@ func makeExtraData(extra []byte) []byte {
if len(extra) == 0 {
// create default extradata
extra, _ = rlp.EncodeToBytes([]interface{}{
- uint(params.VersionMajor<<16 | params.VersionMinor<<8 | params.VersionPatch),
+ uint(params.OPVersionMajor<<16 | params.OPVersionMinor<<8 | params.OPVersionPatch),
"geth",
runtime.Version(),
runtime.GOOS,
@@ -541,6 +596,12 @@ s.txPool.Close()
s.miner.Close()
s.blockchain.Stop()
s.engine.Close()
+ if s.seqRPCService != nil {
+ s.seqRPCService.Close()
+ }
+ if s.historicalRPCService != nil {
+ s.historicalRPCService.Close()
+ }
// Clean shutdown marker as the last thing before closing db
s.shutdownTracker.Stop()
@@ -550,3 +611,33 @@ s.eventMux.Stop()
return nil
}
+
+// HandleRequiredProtocolVersion handles the protocol version signal. This implements opt-in halting,
+// the protocol version data is already logged and metered when signaled through the Engine API.
+func (s *Ethereum) HandleRequiredProtocolVersion(required params.ProtocolVersion) error {
+ var needLevel int
+ switch s.config.RollupHaltOnIncompatibleProtocolVersion {
+ case "major":
+ needLevel = 3
+ case "minor":
+ needLevel = 2
+ case "patch":
+ needLevel = 1
+ default:
+ return nil // do not consider halting if not configured to
+ }
+ haveLevel := 0
+ switch params.OPStackSupport.Compare(required) {
+ case params.OutdatedMajor:
+ haveLevel = 3
+ case params.OutdatedMinor:
+ haveLevel = 2
+ case params.OutdatedPatch:
+ haveLevel = 1
+ }
+ if haveLevel >= needLevel { // halt if we opted in to do so at this granularity
+ log.Error("Opted to halt, unprepared for protocol change", "required", required, "local", params.OPStackSupport)
+ return s.nodeCloser()
+ }
+ return nil
+}
diff --git go-ethereum/internal/ethapi/backend.go op-geth/internal/ethapi/backend.go
index 5f408ba20ba57faf14254a11577f4855a61ad2bf..10201c7549e86e75f2c3490527b340cd245c72b7 100644
--- go-ethereum/internal/ethapi/backend.go
+++ op-geth/internal/ethapi/backend.go
@@ -22,19 +22,19 @@ "context"
"math/big"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/bloombits"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/bloombits"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
// Backend interface provides the common API services (that are provided by
@@ -86,6 +86,8 @@ SubscribeNewTxsEvent(chan<- core.NewTxsEvent) event.Subscription
ChainConfig() *params.ChainConfig
Engine() consensus.Engine
+ HistoricalRPCService() *rpc.Client
+ Genesis() *types.Block
// This is copied from filters.Backend
// eth/filters needs to be initialized from this backend type, so methods needed by
Apply L1 cost in API responses
+11
-11
diff --git go-ethereum/eth/state_accessor.go op-geth/eth/state_accessor.go
index 526361a2b8a6da8d3a5c7a0e56a37238f500cd1c..1d7be7a55971545cf46cfad9295864ecee95509f 100644
--- go-ethereum/eth/state_accessor.go
+++ op-geth/eth/state_accessor.go
@@ -22,16 +22,16 @@ "errors"
"fmt"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/triedb"
)
// noopReleaser is returned in case there is no operation expected
@@ -242,7 +242,7 @@ for idx, tx := range block.Transactions() {
// Assemble the transaction call message and return if the requested offset
msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(block.Header(), eth.blockchain, nil)
+ context := core.NewEVMBlockContext(block.Header(), eth.blockchain, nil, eth.blockchain.Config(), statedb)
if idx == txIndex {
return msg, context, statedb, release, nil
}
API frontend
+283
-39
Format deposit and L1-cost data in transaction responses. Add debug_chainConfig API.
diff --git go-ethereum/internal/ethapi/api.go op-geth/internal/ethapi/api.go
index 863849f4da6a3457fcfbe787c0f041265029523a..a4676ef71388649b6b6b1e0e7b2e138b6974fe26 100644
--- go-ethereum/internal/ethapi/api.go
+++ op-geth/internal/ethapi/api.go
@@ -26,28 +26,29 @@ "strings"
"time"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/accounts/scwallet"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/gasestimator"
- "github.com/ethereum/go-ethereum/eth/tracers/logger"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/trie"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/accounts/scwallet"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/gasestimator"
+ "github.com/tenderly/op-geth/eth/tracers/logger"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/rpc"
+ "github.com/tenderly/op-geth/trie"
"github.com/tyler-smith/go-bip39"
)
@@ -647,6 +648,24 @@ // GetBalance returns the amount of wei for the given address in the state of the
// given block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta
// block numbers are also allowed.
func (s *BlockChainAPI) GetBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error) {
+ header, err := headerByNumberOrHash(ctx, s.b, blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Big
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_getBalance", address, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return &res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
if state == nil || err != nil {
return nil, err
@@ -687,6 +706,22 @@ }
// GetProof returns the Merkle-proof for a given account and optionally some storage keys.
func (s *BlockChainAPI) GetProof(ctx context.Context, address common.Address, storageKeys []string, blockNrOrHash rpc.BlockNumberOrHash) (*AccountResult, error) {
+ header, err := headerByNumberOrHash(ctx, s.b, blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res AccountResult
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_getProof", address, storageKeys, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return &res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
var (
keys = make([]common.Hash, len(storageKeys))
keyLengths = make([]int, len(storageKeys))
@@ -790,7 +825,7 @@ func (s *BlockChainAPI) GetHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (map[string]interface{}, error) {
header, err := s.b.HeaderByNumber(ctx, number)
if header != nil && err == nil {
response := s.rpcMarshalHeader(ctx, header)
- if number == rpc.PendingBlockNumber {
+ if number == rpc.PendingBlockNumber && s.b.ChainConfig().Optimism == nil { // don't remove info if optimism
// Pending header need to nil out a few fields
for _, field := range []string{"hash", "nonce", "miner"} {
response[field] = nil
@@ -821,7 +856,7 @@ func (s *BlockChainAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (map[string]interface{}, error) {
block, err := s.b.BlockByNumber(ctx, number)
if block != nil && err == nil {
response, err := s.rpcMarshalBlock(ctx, block, true, fullTx)
- if err == nil && number == rpc.PendingBlockNumber {
+ if err == nil && number == rpc.PendingBlockNumber && s.b.ChainConfig().Optimism == nil { // don't remove info if optimism
// Pending blocks need to nil out a few fields
for _, field := range []string{"hash", "nonce", "miner"} {
response[field] = nil
@@ -892,10 +927,29 @@ }
// GetCode returns the code stored at the given address in the state for the given block number.
func (s *BlockChainAPI) GetCode(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+ header, err := headerByNumberOrHash(ctx, s.b, blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Bytes
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_getCode", address, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
if state == nil || err != nil {
return nil, err
}
+
code := state.GetCode(address)
return code, state.Error()
}
@@ -904,10 +958,29 @@ // GetStorageAt returns the storage from the state at the given address, key and
// block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta block
// numbers are also allowed.
func (s *BlockChainAPI) GetStorageAt(ctx context.Context, address common.Address, hexKey string, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+ header, err := headerByNumberOrHash(ctx, s.b, blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Bytes
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_getStorageAt", address, hexKey, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
if state == nil || err != nil {
return nil, err
}
+
key, _, err := decodeHash(hexKey)
if err != nil {
return nil, fmt.Errorf("unable to decode storage key: %s", err)
@@ -916,6 +989,18 @@ res := state.GetState(address, key)
return res[:], state.Error()
}
+// The HeaderByNumberOrHash method returns a nil error and nil header
+// if the header is not found, but only for nonexistent block numbers. This is
+// different from StateAndHeaderByNumberOrHash. To account for this discrepancy,
+// headerOrNumberByHash will properly convert the error into an ethereum.NotFound.
+func headerByNumberOrHash(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrHash) (*types.Header, error) {
+ header, err := b.HeaderByNumberOrHash(ctx, blockNrOrHash)
+ if header == nil {
+ return nil, fmt.Errorf("header %w", ethereum.NotFound)
+ }
+ return header, err
+}
+
// GetBlockReceipts returns the block receipts for the given block hash or number or tag.
func (s *BlockChainAPI) GetBlockReceipts(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) ([]map[string]interface{}, error) {
block, err := s.b.BlockByNumberOrHash(ctx, blockNrOrHash)
@@ -938,7 +1023,7 @@ signer := types.MakeSigner(s.b.ChainConfig(), block.Number(), block.Time())
result := make([]map[string]interface{}, len(receipts))
for i, receipt := range receipts {
- result[i] = marshalReceipt(receipt, block.Hash(), block.NumberU64(), signer, txs[i], i)
+ result[i] = marshalReceipt(receipt, block.Hash(), block.NumberU64(), signer, txs[i], i, s.b.ChainConfig())
}
return result, nil
@@ -1093,7 +1178,7 @@ // this makes sure resources are cleaned up.
defer cancel()
// Get a new instance of the EVM.
- blockCtx := core.NewEVMBlockContext(header, NewChainContext(ctx, b), nil)
+ blockCtx := core.NewEVMBlockContext(header, NewChainContext(ctx, b), nil, b.ChainConfig(), state)
if blockOverrides != nil {
blockOverrides.Apply(&blockCtx)
}
@@ -1149,6 +1234,25 @@ if blockNrOrHash == nil {
latest := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)
blockNrOrHash = &latest
}
+
+ header, err := headerByNumberOrHash(ctx, s.b, *blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Bytes
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_call", args, blockNrOrHash, overrides)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
result, err := DoCall(ctx, s.b, args, *blockNrOrHash, overrides, blockOverrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap())
if err != nil {
return nil, err
@@ -1207,6 +1311,25 @@ bNrOrHash := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)
if blockNrOrHash != nil {
bNrOrHash = *blockNrOrHash
}
+
+ header, err := headerByNumberOrHash(ctx, s.b, bNrOrHash)
+ if err != nil {
+ return 0, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Uint64
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_estimateGas", args, blockNrOrHash)
+ if err != nil {
+ return 0, fmt.Errorf("historical backend error: %w", err)
+ }
+ return res, nil
+ } else {
+ return 0, rpc.ErrNoHistoricalFallback
+ }
+ }
+
return DoEstimateGas(ctx, s.b, args, bNrOrHash, overrides, s.b.RPCGasCap())
}
@@ -1251,7 +1374,7 @@
// RPCMarshalBlock converts the given block to the RPC output which depends on fullTx. If inclTx is true transactions are
// returned. When fullTx is true the returned block contains full transaction details, otherwise it will only contain
// transaction hashes.
-func RPCMarshalBlock(block *types.Block, inclTx bool, fullTx bool, config *params.ChainConfig) map[string]interface{} {
+func RPCMarshalBlock(ctx context.Context, block *types.Block, inclTx bool, fullTx bool, config *params.ChainConfig, backend Backend) (map[string]interface{}, error) {
fields := RPCMarshalHeader(block.Header())
fields["size"] = hexutil.Uint64(block.Size())
@@ -1261,7 +1384,7 @@ return tx.Hash()
}
if fullTx {
formatTx = func(idx int, tx *types.Transaction) interface{} {
- return newRPCTransactionFromBlockIndex(block, uint64(idx), config)
+ return newRPCTransactionFromBlockIndex(ctx, block, uint64(idx), config, backend)
}
}
txs := block.Transactions()
@@ -1280,7 +1403,7 @@ fields["uncles"] = uncleHashes
if block.Header().WithdrawalsHash != nil {
fields["withdrawals"] = block.Withdrawals()
}
- return fields
+ return fields, nil
}
// rpcMarshalHeader uses the generalized output filler, then adds the total difficulty field, which requires
@@ -1294,7 +1417,10 @@
// rpcMarshalBlock uses the generalized output filler, then adds the total difficulty field, which requires
// a `BlockchainAPI`.
func (s *BlockChainAPI) rpcMarshalBlock(ctx context.Context, b *types.Block, inclTx bool, fullTx bool) (map[string]interface{}, error) {
- fields := RPCMarshalBlock(b, inclTx, fullTx, s.b.ChainConfig())
+ fields, err := RPCMarshalBlock(ctx, b, inclTx, fullTx, s.b.ChainConfig(), s.b)
+ if err != nil {
+ return nil, err
+ }
if inclTx {
fields["totalDifficulty"] = (*hexutil.Big)(s.b.GetTd(ctx, b.Hash()))
}
@@ -1325,11 +1451,18 @@ V *hexutil.Big `json:"v"`
R *hexutil.Big `json:"r"`
S *hexutil.Big `json:"s"`
YParity *hexutil.Uint64 `json:"yParity,omitempty"`
+
+ // deposit-tx only
+ SourceHash *common.Hash `json:"sourceHash,omitempty"`
+ Mint *hexutil.Big `json:"mint,omitempty"`
+ IsSystemTx *bool `json:"isSystemTx,omitempty"`
+ // deposit-tx post-Canyon only
+ DepositReceiptVersion *hexutil.Uint64 `json:"depositReceiptVersion,omitempty"`
}
// newRPCTransaction returns a transaction that will serialize to the RPC
// representation, with the given location metadata set (if available).
-func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber uint64, blockTime uint64, index uint64, baseFee *big.Int, config *params.ChainConfig) *RPCTransaction {
+func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber uint64, blockTime uint64, index uint64, baseFee *big.Int, config *params.ChainConfig, receipt *types.Receipt) *RPCTransaction {
signer := types.MakeSigner(config, new(big.Int).SetUint64(blockNumber), blockTime)
from, _ := types.Sender(signer, tx)
v, r, s := tx.RawSignatureValues()
@@ -1354,7 +1487,27 @@ result.TransactionIndex = (*hexutil.Uint64)(&index)
}
switch tx.Type() {
+ case types.DepositTxType:
+ srcHash := tx.SourceHash()
+ isSystemTx := tx.IsSystemTx()
+ result.SourceHash = &srcHash
+ if isSystemTx {
+ // Only include IsSystemTx when true
+ result.IsSystemTx = &isSystemTx
+ }
+ result.Mint = (*hexutil.Big)(tx.Mint())
+ if receipt != nil && receipt.DepositNonce != nil {
+ result.Nonce = hexutil.Uint64(*receipt.DepositNonce)
+ if receipt.DepositReceiptVersion != nil {
+ result.DepositReceiptVersion = new(hexutil.Uint64)
+ *result.DepositReceiptVersion = hexutil.Uint64(*receipt.DepositReceiptVersion)
+ }
+ }
case types.LegacyTxType:
+ if v.Sign() == 0 && r.Sign() == 0 && s.Sign() == 0 { // pre-bedrock relayed tx does not have a signature
+ result.ChainID = (*hexutil.Big)(new(big.Int).Set(config.ChainID))
+ break
+ }
// if a legacy transaction has an EIP-155 chain id, include it explicitly
if id := tx.ChainId(); id.Sign() != 0 {
result.ChainID = (*hexutil.Big)(id)
@@ -1423,20 +1576,36 @@ blockNumber = uint64(0)
blockTime = uint64(0)
)
if current != nil {
- baseFee = eip1559.CalcBaseFee(config, current)
+ baseFee = eip1559.CalcBaseFee(config, current, current.Time+1)
blockNumber = current.Number.Uint64()
blockTime = current.Time
}
- return newRPCTransaction(tx, common.Hash{}, blockNumber, blockTime, 0, baseFee, config)
+ return newRPCTransaction(tx, common.Hash{}, blockNumber, blockTime, 0, baseFee, config, nil)
}
// newRPCTransactionFromBlockIndex returns a transaction that will serialize to the RPC representation.
-func newRPCTransactionFromBlockIndex(b *types.Block, index uint64, config *params.ChainConfig) *RPCTransaction {
+func newRPCTransactionFromBlockIndex(ctx context.Context, b *types.Block, index uint64, config *params.ChainConfig, backend Backend) *RPCTransaction {
txs := b.Transactions()
if index >= uint64(len(txs)) {
return nil
}
- return newRPCTransaction(txs[index], b.Hash(), b.NumberU64(), b.Time(), index, b.BaseFee(), config)
+ tx := txs[index]
+ rcpt := depositTxReceipt(ctx, b.Hash(), index, backend, tx)
+ return newRPCTransaction(tx, b.Hash(), b.NumberU64(), b.Time(), index, b.BaseFee(), config, rcpt)
+}
+
+func depositTxReceipt(ctx context.Context, blockHash common.Hash, index uint64, backend Backend, tx *types.Transaction) *types.Receipt {
+ if tx.Type() != types.DepositTxType {
+ return nil
+ }
+ receipts, err := backend.GetReceipts(ctx, blockHash)
+ if err != nil {
+ return nil
+ }
+ if index >= uint64(len(receipts)) {
+ return nil
+ }
+ return receipts[index]
}
// newRPCRawTransactionFromBlockIndex returns the bytes of a transaction given a block and a transaction index.
@@ -1465,6 +1634,21 @@ bNrOrHash := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)
if blockNrOrHash != nil {
bNrOrHash = *blockNrOrHash
}
+
+ header, err := headerByNumberOrHash(ctx, s.b, bNrOrHash)
+ if err == nil && header != nil && s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res accessListResult
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_createAccessList", args, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return &res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
acl, gasUsed, vmerr, err := AccessList(ctx, s.b, bNrOrHash, args)
if err != nil {
return nil, err
@@ -1570,7 +1754,7 @@
// GetTransactionByBlockNumberAndIndex returns the transaction for the given block number and index.
func (s *TransactionAPI) GetTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) *RPCTransaction {
if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil {
- return newRPCTransactionFromBlockIndex(block, uint64(index), s.b.ChainConfig())
+ return newRPCTransactionFromBlockIndex(ctx, block, uint64(index), s.b.ChainConfig(), s.b)
}
return nil
}
@@ -1578,7 +1762,7 @@
// GetTransactionByBlockHashAndIndex returns the transaction for the given block hash and index.
func (s *TransactionAPI) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) *RPCTransaction {
if block, _ := s.b.BlockByHash(ctx, blockHash); block != nil {
- return newRPCTransactionFromBlockIndex(block, uint64(index), s.b.ChainConfig())
+ return newRPCTransactionFromBlockIndex(ctx, block, uint64(index), s.b.ChainConfig(), s.b)
}
return nil
}
@@ -1610,10 +1794,29 @@ }
return (*hexutil.Uint64)(&nonce), nil
}
// Resolve block number and use its state to ask for the nonce
+ header, err := headerByNumberOrHash(ctx, s.b, blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Uint64
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_getTransactionCount", address, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return &res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
if state == nil || err != nil {
return nil, err
}
+
nonce := state.GetNonce(address)
return (*hexutil.Uint64)(&nonce), state.Error()
}
@@ -1636,7 +1839,8 @@ header, err := s.b.HeaderByHash(ctx, blockHash)
if err != nil {
return nil, err
}
- return newRPCTransaction(tx, blockHash, blockNumber, header.Time, index, header.BaseFee, s.b.ChainConfig()), nil
+ rcpt := depositTxReceipt(ctx, blockHash, index, s.b, tx)
+ return newRPCTransaction(tx, blockHash, blockNumber, header.Time, index, header.BaseFee, s.b.ChainConfig(), rcpt), nil
}
// GetRawTransactionByHash returns the bytes of the transaction for the given hash.
@@ -1679,11 +1883,11 @@ receipt := receipts[index]
// Derive the sender.
signer := types.MakeSigner(s.b.ChainConfig(), header.Number, header.Time)
- return marshalReceipt(receipt, blockHash, blockNumber, signer, tx, int(index)), nil
+ return marshalReceipt(receipt, blockHash, blockNumber, signer, tx, int(index), s.b.ChainConfig()), nil
}
// marshalReceipt marshals a transaction receipt into a JSON object.
-func marshalReceipt(receipt *types.Receipt, blockHash common.Hash, blockNumber uint64, signer types.Signer, tx *types.Transaction, txIndex int) map[string]interface{} {
+func marshalReceipt(receipt *types.Receipt, blockHash common.Hash, blockNumber uint64, signer types.Signer, tx *types.Transaction, txIndex int, chainConfig *params.ChainConfig) map[string]interface{} {
from, _ := types.Sender(signer, tx)
fields := map[string]interface{}{
@@ -1700,6 +1904,32 @@ "logs": receipt.Logs,
"logsBloom": receipt.Bloom,
"type": hexutil.Uint(tx.Type()),
"effectiveGasPrice": (*hexutil.Big)(receipt.EffectiveGasPrice),
+ }
+
+ if chainConfig.Optimism != nil && !tx.IsDepositTx() {
+ fields["l1GasPrice"] = (*hexutil.Big)(receipt.L1GasPrice)
+ fields["l1GasUsed"] = (*hexutil.Big)(receipt.L1GasUsed)
+ fields["l1Fee"] = (*hexutil.Big)(receipt.L1Fee)
+ // Fields removed with Ecotone
+ if receipt.FeeScalar != nil {
+ fields["l1FeeScalar"] = receipt.FeeScalar.String()
+ }
+ // Fields added in Ecotone
+ if receipt.L1BlobBaseFee != nil {
+ fields["l1BlobBaseFee"] = (*hexutil.Big)(receipt.L1BlobBaseFee)
+ }
+ if receipt.L1BaseFeeScalar != nil {
+ fields["l1BaseFeeScalar"] = hexutil.Uint64(*receipt.L1BaseFeeScalar)
+ }
+ if receipt.L1BlobBaseFeeScalar != nil {
+ fields["l1BlobBaseFeeScalar"] = hexutil.Uint64(*receipt.L1BlobBaseFeeScalar)
+ }
+ }
+ if chainConfig.Optimism != nil && tx.IsDepositTx() && receipt.DepositNonce != nil {
+ fields["depositNonce"] = hexutil.Uint64(*receipt.DepositNonce)
+ if receipt.DepositReceiptVersion != nil {
+ fields["depositReceiptVersion"] = hexutil.Uint64(*receipt.DepositReceiptVersion)
+ }
}
// Assign receipt status or post state.
@@ -2104,6 +2334,10 @@
// SetHead rewinds the head of the blockchain to a previous block.
func (api *DebugAPI) SetHead(number hexutil.Uint64) {
api.b.SetHead(uint64(number))
+}
+
+func (api *DebugAPI) ChainConfig() *params.ChainConfig {
+ return api.b.ChainConfig()
}
// NetAPI offers network related RPC methods
diff --git go-ethereum/rpc/errors.go op-geth/rpc/errors.go
index 438aff218c2e306d322160d8be8dcac16dd0dfa2..67c523d11a36294e4448988dc4c906f38541ec04 100644
--- go-ethereum/rpc/errors.go
+++ op-geth/rpc/errors.go
@@ -73,6 +73,16 @@ errMsgResponseTooLarge = "response too large"
errMsgBatchTooLarge = "batch too large"
)
+var ErrNoHistoricalFallback = NoHistoricalFallbackError{}
+
+type NoHistoricalFallbackError struct{}
+
+func (e NoHistoricalFallbackError) ErrorCode() int { return -32801 }
+
+func (e NoHistoricalFallbackError) Error() string {
+ return "no historical RPC is available for this historical (pre-bedrock) execution request"
+}
+
type methodNotFoundError struct{ method string }
func (e *methodNotFoundError) ErrorCode() int { return -32601 }
Tracer RPC daisy-chain
+74
-27
Forward pre-bedrock tracing calls to legacy node.
diff --git go-ethereum/eth/tracers/api.go op-geth/eth/tracers/api.go
index 68331082052648ad30e8f70a20aee0488ec7b7eb..a11eaef71d8b667b78a51c656d57abbc52ff579e 100644
--- go-ethereum/eth/tracers/api.go
+++ op-geth/eth/tracers/api.go
@@ -22,26 +22,27 @@ "context"
"encoding/json"
"errors"
"fmt"
+ "math/big"
"os"
"runtime"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers/logger"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers/logger"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/rpc"
)
const (
@@ -66,8 +67,6 @@ // for tracing. The creation of trace state will be paused if the unused
// trace states exceed this limit.
maximumPendingTraceStates = 128
)
-
-var errTxNotFound = errors.New("transaction not found")
// StateReleaseFunc is used to deallocate resources held by constructing a
// historical state for tracing purposes.
@@ -87,6 +86,7 @@ Engine() consensus.Engine
ChainDb() ethdb.Database
StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, StateReleaseFunc, error)
StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, StateReleaseFunc, error)
+ HistoricalRPCService() *rpc.Client
}
// API is the collection of tracing APIs exposed over the private debugging endpoint.
@@ -208,6 +208,7 @@
// TraceChain returns the structured logs created during the execution of EVM
// between two blocks (excluding start) and returns them as a JSON object.
func (api *API) TraceChain(ctx context.Context, start, end rpc.BlockNumber, config *TraceConfig) (*rpc.Subscription, error) { // Fetch the block interval that we want to trace
+ // TODO: Need to implement a fallback for this
from, err := api.blockByNumber(ctx, start)
if err != nil {
return nil, err
@@ -266,7 +267,7 @@ // Fetch and execute the block trace taskCh
for task := range taskCh {
var (
signer = types.MakeSigner(api.backend.ChainConfig(), task.block.Number(), task.block.Time())
- blockCtx = core.NewEVMBlockContext(task.block.Header(), api.chainContext(ctx), nil)
+ blockCtx = core.NewEVMBlockContext(task.block.Header(), api.chainContext(ctx), nil, api.backend.ChainConfig(), task.statedb)
)
// Trace all the transactions contained within
for i, tx := range task.block.Transactions() {
@@ -436,6 +437,20 @@ block, err := api.blockByNumber(ctx, number)
if err != nil {
return nil, err
}
+
+ if api.backend.ChainConfig().IsOptimismPreBedrock(block.Number()) {
+ if api.backend.HistoricalRPCService() != nil {
+ var histResult []*txTraceResult
+ err = api.backend.HistoricalRPCService().CallContext(ctx, &histResult, "debug_traceBlockByNumber", number, config)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return histResult, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
return api.traceBlock(ctx, block, config)
}
@@ -446,6 +461,20 @@ block, err := api.blockByHash(ctx, hash)
if err != nil {
return nil, err
}
+
+ if api.backend.ChainConfig().IsOptimismPreBedrock(block.Number()) {
+ if api.backend.HistoricalRPCService() != nil {
+ var histResult []*txTraceResult
+ err = api.backend.HistoricalRPCService().CallContext(ctx, &histResult, "debug_traceBlockByHash", hash, config)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return histResult, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
return api.traceBlock(ctx, block, config)
}
@@ -495,6 +524,7 @@ // IntermediateRoots executes a block (bad- or canon- or side-), and returns a list
// of intermediate roots: the stateroot after each transaction.
func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config *TraceConfig) ([]common.Hash, error) {
block, _ := api.blockByHash(ctx, hash)
+ // TODO: Cannot get intermediate roots for pre-bedrock block without daisy chain
if block == nil {
// Check in the bad blocks
block = rawdb.ReadBadBlock(api.backend.ChainDb(), hash)
@@ -523,7 +553,7 @@ var (
roots []common.Hash
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
chainConfig = api.backend.ChainConfig()
- vmctx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+ vmctx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, chainConfig, statedb)
deleteEmptyObjects = chainConfig.IsEIP158(block.Number())
)
for i, tx := range block.Transactions() {
@@ -599,7 +629,7 @@ var (
txs = block.Transactions()
blockHash = block.Hash()
is158 = api.backend.ChainConfig().IsEIP158(block.Number())
- blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+ blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, api.backend.ChainConfig(), statedb)
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
results = make([]*txTraceResult, len(txs))
)
@@ -632,7 +662,6 @@ // Execute all the transaction contained within the block concurrently
var (
txs = block.Transactions()
blockHash = block.Hash()
- blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
results = make([]*txTraceResult, len(txs))
pend sync.WaitGroup
@@ -648,6 +677,7 @@ go func() {
defer pend.Done()
// Fetch and execute the next transaction trace tasks
for task := range jobs {
+ blockCtx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, api.backend.ChainConfig(), task.statedb)
msg, _ := core.TransactionToMessage(txs[task.index], signer, block.BaseFee())
txctx := &Context{
BlockHash: blockHash,
@@ -667,6 +697,7 @@ }
// Feed the transactions into the tracers and return
var failed error
+ blockCtx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, api.backend.ChainConfig(), statedb)
txloop:
for i, tx := range txs {
// Send the trace task over for execution
@@ -744,7 +775,7 @@ var (
dumps []string
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
chainConfig = api.backend.ChainConfig()
- vmctx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+ vmctx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, chainConfig, statedb)
canon = true
)
// Check if there are any overrides: the caller may wish to enable a future
@@ -826,18 +857,29 @@
// TraceTransaction returns the structured logs created during the execution of EVM
// and returns them as a JSON object.
func (api *API) TraceTransaction(ctx context.Context, hash common.Hash, config *TraceConfig) (interface{}, error) {
- found, _, blockHash, blockNumber, index, err := api.backend.GetTransaction(ctx, hash)
+ _, _, blockHash, blockNumber, index, err := api.backend.GetTransaction(ctx, hash)
if err != nil {
return nil, ethapi.NewTxIndexingError()
}
- // Only mined txes are supported
- if !found {
- return nil, errTxNotFound
+
+ if api.backend.ChainConfig().IsOptimismPreBedrock(new(big.Int).SetUint64(blockNumber)) {
+ if api.backend.HistoricalRPCService() != nil {
+ var histResult json.RawMessage
+ err := api.backend.HistoricalRPCService().CallContext(ctx, &histResult, "debug_traceTransaction", hash, config)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return histResult, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
}
+
// It shouldn't happen in practice.
if blockNumber == 0 {
return nil, errors.New("genesis is not traceable")
}
+
reexec := defaultTraceReexec
if config != nil && config.Reexec != nil {
reexec = *config.Reexec
@@ -894,6 +936,11 @@ }
if err != nil {
return nil, err
}
+
+ if api.backend.ChainConfig().IsOptimismPreBedrock(block.Number()) {
+ return nil, errors.New("l2geth does not have a debug_traceCall method")
+ }
+
// try to recompute the state
reexec := defaultTraceReexec
if config != nil && config.Reexec != nil {
@@ -910,7 +957,7 @@ return nil, err
}
defer release()
- vmctx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+ vmctx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, api.backend.ChainConfig(), statedb)
// Apply the customization rules if required.
if config != nil {
if err := config.StateOverrides.Apply(statedb); err != nil {
Daisy Chain tests
+409
-56
diff --git go-ethereum/eth/tracers/api_test.go op-geth/eth/tracers/api_test.go
index d8e4b9a4ef3d21c431b624efc589227d345d683b..84842cfd4e31a71e33d0642cf73b9cb54c9b83ee 100644
--- go-ethereum/eth/tracers/api_test.go
+++ op-geth/eth/tracers/api_test.go
@@ -23,26 +23,31 @@ "encoding/json"
"errors"
"fmt"
"math/big"
+ "net"
+ "net/http"
"reflect"
"sync/atomic"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/tracers/logger"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/davecgh/go-spew/spew"
+ "github.com/stretchr/testify/mock"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/tracers/logger"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
"golang.org/x/exp/slices"
)
@@ -51,6 +56,66 @@ errStateNotFound = errors.New("state not found")
errBlockNotFound = errors.New("block not found")
)
+type mockHistoricalBackend struct {
+ mock.Mock
+}
+
+// mockHistoricalBackend does not have a TraceCall, because pre-bedrock there is no debug_traceCall available
+
+func (m *mockHistoricalBackend) TraceBlockByNumber(ctx context.Context, number rpc.BlockNumber, config *TraceConfig) ([]*txTraceResult, error) {
+ ret := m.Mock.MethodCalled("TraceBlockByNumber", number, config)
+ return ret[0].([]*txTraceResult), *ret[1].(*error)
+}
+
+func (m *mockHistoricalBackend) ExpectTraceBlockByNumber(number rpc.BlockNumber, config *TraceConfig, out []*txTraceResult, err error) {
+ m.Mock.On("TraceBlockByNumber", number, config).Once().Return(out, &err)
+}
+
+func (m *mockHistoricalBackend) TraceTransaction(ctx context.Context, hash common.Hash, config *TraceConfig) (interface{}, error) {
+ ret := m.Mock.MethodCalled("TraceTransaction", hash, config)
+ return ret[0], *ret[1].(*error)
+}
+
+func (m *mockHistoricalBackend) ExpectTraceTransaction(hash common.Hash, config *TraceConfig, out interface{}, err error) {
+ jsonOut, _ := json.Marshal(out)
+ m.Mock.On("TraceTransaction", hash, config).Once().Return(json.RawMessage(jsonOut), &err)
+}
+
+func newMockHistoricalBackend(t *testing.T, backend *mockHistoricalBackend) string {
+ s := rpc.NewServer()
+ err := node.RegisterApis([]rpc.API{
+ {
+ Namespace: "debug",
+ Service: backend,
+ Public: true,
+ Authenticated: false,
+ },
+ }, nil, s)
+ if err != nil {
+ t.Fatalf("error creating mock historical backend: %v", err)
+ }
+
+ hdlr := node.NewHTTPHandlerStack(s, []string{"*"}, []string{"*"}, nil)
+ mux := http.NewServeMux()
+ mux.Handle("/", hdlr)
+
+ listener, err := net.Listen("tcp", "127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("error creating mock historical backend listener: %v", err)
+ }
+
+ go func() {
+ httpS := &http.Server{Handler: mux}
+ httpS.Serve(listener)
+
+ t.Cleanup(func() {
+ httpS.Shutdown(context.Background())
+ })
+ }()
+
+ return fmt.Sprintf("http://%s", listener.Addr().String())
+}
+
type testBackend struct {
chainConfig *params.ChainConfig
engine consensus.Engine
@@ -59,15 +124,28 @@ chain *core.BlockChain
refHook func() // Hook is invoked when the requested state is referenced
relHook func() // Hook is invoked when the requested state is released
+
+ historical *rpc.Client
+ mockHistorical *mockHistoricalBackend
}
// testBackend creates a new test backend. OBS: After test is done, teardown must be
// invoked in order to release associated resources.
func newTestBackend(t *testing.T, n int, gspec *core.Genesis, generator func(i int, b *core.BlockGen)) *testBackend {
+ mock := new(mockHistoricalBackend)
+ historicalAddr := newMockHistoricalBackend(t, mock)
+
+ historicalClient, err := rpc.Dial(historicalAddr)
+ if err != nil {
+ t.Fatalf("error making historical client: %v", err)
+ }
+
backend := &testBackend{
- chainConfig: gspec.Config,
- engine: ethash.NewFaker(),
- chaindb: rawdb.NewMemoryDatabase(),
+ chainConfig: gspec.Config,
+ engine: ethash.NewFaker(),
+ chaindb: rawdb.NewMemoryDatabase(),
+ historical: historicalClient,
+ mockHistorical: mock,
}
// Generate blocks for testing
_, blocks, _ := core.GenerateChainWithGenesis(gspec, backend.engine, n, generator)
@@ -172,7 +250,7 @@ signer := types.MakeSigner(b.chainConfig, block.Number(), block.Time())
for idx, tx := range block.Transactions() {
msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(block.Header(), b.chain, nil)
+ context := core.NewEVMBlockContext(block.Header(), b.chain, nil, b.chainConfig, statedb)
if idx == txIndex {
return msg, context, statedb, release, nil
}
@@ -183,6 +261,10 @@ }
statedb.Finalise(vmenv.ChainConfig().IsEIP158(block.Number()))
}
return nil, vm.BlockContext{}, nil, nil, fmt.Errorf("transaction index %d out of range for block %#x", txIndex, block.Hash())
+}
+
+func (b *testBackend) HistoricalRPCService() *rpc.Client {
+ return b.historical
}
func TestTraceCall(t *testing.T) {
@@ -450,11 +532,58 @@ StructLogs: []logger.StructLogRes{},
}) {
t.Error("Transaction tracing result is different")
}
+}
+func TestTraceTransactionHistorical(t *testing.T) {
+ t.Parallel()
- // Test non-existent transaction
- _, err = api.TraceTransaction(context.Background(), common.Hash{42}, nil)
- if !errors.Is(err, errTxNotFound) {
- t.Fatalf("want %v, have %v", errTxNotFound, err)
+ // Initialize test accounts
+ accounts := newAccounts(2)
+ genesis := &core.Genesis{
+ Config: params.OptimismTestConfig,
+ Alloc: core.GenesisAlloc{
+ accounts[0].addr: {Balance: big.NewInt(params.Ether)},
+ accounts[1].addr: {Balance: big.NewInt(params.Ether)},
+ },
+ }
+ target := common.Hash{}
+ signer := types.HomesteadSigner{}
+ backend := newTestBackend(t, 1, genesis, func(i int, b *core.BlockGen) {
+ // Transfer from account[0] to account[1]
+ // value: 1000 wei
+ // fee: 0 wei
+ tx, _ := types.SignTx(types.NewTransaction(uint64(i), accounts[1].addr, big.NewInt(1000), params.TxGas, b.BaseFee(), nil), signer, accounts[0].key)
+ b.AddTx(tx)
+ target = tx.Hash()
+ })
+ defer backend.mockHistorical.AssertExpectations(t)
+ defer backend.chain.Stop()
+ backend.mockHistorical.ExpectTraceTransaction(
+ target,
+ nil,
+ logger.ExecutionResult{
+ Gas: params.TxGas,
+ Failed: false,
+ ReturnValue: "",
+ StructLogs: []logger.StructLogRes{},
+ },
+ nil)
+ api := NewAPI(backend)
+ result, err := api.TraceTransaction(context.Background(), target, nil)
+ if err != nil {
+ t.Errorf("Failed to trace transaction %v", err)
+ }
+ var have *logger.ExecutionResult
+ spew.Dump(result)
+ if err := json.Unmarshal(result.(json.RawMessage), &have); err != nil {
+ t.Errorf("failed to unmarshal result %v", err)
+ }
+ if !reflect.DeepEqual(have, &logger.ExecutionResult{
+ Gas: params.TxGas,
+ Failed: false,
+ ReturnValue: "",
+ StructLogs: []logger.StructLogRes{},
+ }) {
+ t.Error("Transaction tracing result is different")
}
}
@@ -545,6 +674,59 @@ want := tc.want
if string(have) != want {
t.Errorf("test %d, result mismatch, have\n%v\n, want\n%v\n", i, string(have), want)
}
+ }
+}
+
+func TestTraceBlockHistorical(t *testing.T) {
+ t.Parallel()
+
+ // Initialize test accounts
+ accounts := newAccounts(3)
+ genesis := &core.Genesis{
+ Config: params.OptimismTestConfig,
+ Alloc: core.GenesisAlloc{
+ accounts[0].addr: {Balance: big.NewInt(params.Ether)},
+ accounts[1].addr: {Balance: big.NewInt(params.Ether)},
+ accounts[2].addr: {Balance: big.NewInt(params.Ether)},
+ },
+ }
+ genBlocks := 10
+ signer := types.HomesteadSigner{}
+ backend := newTestBackend(t, genBlocks, genesis, func(i int, b *core.BlockGen) {
+ // Transfer from account[0] to account[1]
+ // value: 1000 wei
+ // fee: 0 wei
+ tx, _ := types.SignTx(types.NewTransaction(uint64(i), accounts[1].addr, big.NewInt(1000), params.TxGas, b.BaseFee(), nil), signer, accounts[0].key)
+ b.AddTx(tx)
+ })
+ defer backend.mockHistorical.AssertExpectations(t)
+ defer backend.chain.Stop()
+ api := NewAPI(backend)
+
+ var expectErr error
+ var config *TraceConfig
+ blockNumber := rpc.BlockNumber(3)
+ want := `[{"txHash":"0x0000000000000000000000000000000000000000000000000000000000000000","result":{"failed":false,"gas":21000,"returnValue":"","structLogs":[]}}]`
+ var ret []*txTraceResult
+ _ = json.Unmarshal([]byte(want), &ret)
+
+ backend.mockHistorical.ExpectTraceBlockByNumber(blockNumber, config, ret, nil)
+
+ result, err := api.TraceBlockByNumber(context.Background(), blockNumber, config)
+ if expectErr != nil {
+ if err == nil {
+ t.Errorf("want error %v", expectErr)
+ }
+ if !reflect.DeepEqual(err, expectErr) {
+ t.Errorf("error mismatch, want %v, get %v", expectErr, err)
+ }
+ }
+ if err != nil {
+ t.Errorf("want no error, have %v", err)
+ }
+ have, _ := json.Marshal(result)
+ if string(have) != want {
+ t.Errorf("result mismatch, have\n%v\n, want\n%v\n", string(have), want)
}
}
diff --git go-ethereum/ethclient/ethclient_test.go op-geth/ethclient/ethclient_test.go
index 0d2675f8d10d8d126c43b1063689bb08a561159f..eb09df080d4a3bf0a06cf3a9df2337cae28e3244 100644
--- go-ethereum/ethclient/ethclient_test.go
+++ op-geth/ethclient/ethclient_test.go
@@ -20,22 +20,30 @@ import (
"bytes"
"context"
"errors"
+ "fmt"
"math/big"
+ "net"
+ "net/http"
"reflect"
"testing"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/internal/ethapi"
+
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
// Verify that Client implements the ethereum interfaces.
@@ -193,6 +201,21 @@ Timestamp: 9000,
BaseFee: big.NewInt(params.InitialBaseFee),
}
+var genesisForHistorical = &core.Genesis{
+ Config: params.OptimismTestConfig,
+ Alloc: core.GenesisAlloc{testAddr: {Balance: testBalance}},
+ ExtraData: []byte("test genesis"),
+ Timestamp: 9000,
+ BaseFee: big.NewInt(params.InitialBaseFee),
+}
+
+var depositTx = types.NewTx(&types.DepositTx{
+ Value: big.NewInt(12),
+ Gas: params.TxGas + 2000,
+ To: &common.Address{2},
+ Data: make([]byte, 500),
+})
+
var testTx1 = types.MustSignNewTx(testKey, types.LatestSigner(genesis.Config), &types.LegacyTx{
Nonce: 0,
Value: big.NewInt(12),
@@ -209,9 +232,77 @@ Gas: params.TxGas,
To: &common.Address{2},
})
-func newTestBackend(t *testing.T) (*node.Node, []*types.Block) {
- // Generate test chain.
- blocks := generateTestChain()
+type mockHistoricalBackend struct{}
+
+func (m *mockHistoricalBackend) Call(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *ethapi.StateOverride) (hexutil.Bytes, error) {
+ num, ok := blockNrOrHash.Number()
+ if ok && num == 1 {
+ return hexutil.Bytes("test"), nil
+ }
+ return nil, ethereum.NotFound
+}
+
+func (m *mockHistoricalBackend) EstimateGas(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash *rpc.BlockNumberOrHash) (hexutil.Uint64, error) {
+ num, ok := blockNrOrHash.Number()
+ if ok && num == 1 {
+ return hexutil.Uint64(12345), nil
+ }
+ return 0, ethereum.NotFound
+}
+
+func newMockHistoricalBackend(t *testing.T) string {
+ s := rpc.NewServer()
+ err := node.RegisterApis([]rpc.API{
+ {
+ Namespace: "eth",
+ Service: new(mockHistoricalBackend),
+ Public: true,
+ Authenticated: false,
+ },
+ }, nil, s)
+ if err != nil {
+ t.Fatalf("error creating mock historical backend: %v", err)
+ }
+
+ hdlr := node.NewHTTPHandlerStack(s, []string{"*"}, []string{"*"}, nil)
+ mux := http.NewServeMux()
+ mux.Handle("/", hdlr)
+
+ listener, err := net.Listen("tcp", "127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("error creating mock historical backend listener: %v", err)
+ }
+
+ go func() {
+ httpS := &http.Server{Handler: mux}
+ httpS.Serve(listener)
+
+ t.Cleanup(func() {
+ httpS.Shutdown(context.Background())
+ })
+ }()
+
+ return fmt.Sprintf("http://%s", listener.Addr().String())
+}
+
+func newTestBackend(t *testing.T, enableHistoricalState bool) (*node.Node, []*types.Block) {
+ histAddr := newMockHistoricalBackend(t)
+
+ var consensusEngine consensus.Engine
+ var actualGenesis *core.Genesis
+ var chainLength int
+ if enableHistoricalState {
+ actualGenesis = genesisForHistorical
+ consensusEngine = beacon.New(ethash.NewFaker())
+ chainLength = 10
+ } else {
+ actualGenesis = genesis
+ consensusEngine = ethash.NewFaker()
+ chainLength = 2
+ }
+
+ // Generate test chain
+ blocks := generateTestChain(consensusEngine, actualGenesis, chainLength)
// Create node
n, err := node.New(&node.Config{})
@@ -219,11 +310,18 @@ if err != nil {
t.Fatalf("can't create new node: %v", err)
}
// Create Ethereum Service
- config := ðconfig.Config{Genesis: genesis}
+ config := ðconfig.Config{Genesis: actualGenesis}
+ if enableHistoricalState {
+ config.RollupHistoricalRPC = histAddr
+ config.RollupHistoricalRPCTimeout = time.Second * 5
+ }
ethservice, err := eth.New(n, config)
if err != nil {
t.Fatalf("can't create new ethereum service: %v", err)
}
+ if enableHistoricalState { // swap to the pre-bedrock consensus-engine that we used to generate the historical blocks
+ ethservice.BlockChain().Engine().(*beacon.Beacon).SwapInner(ethash.NewFaker())
+ }
// Import the test chain.
if err := n.Start(); err != nil {
t.Fatalf("can't start test node: %v", err)
@@ -231,6 +329,7 @@ }
if _, err := ethservice.BlockChain().InsertChain(blocks[1:]); err != nil {
t.Fatalf("can't import test blocks: %v", err)
}
+
// Ensure the tx indexing is fully generated
for ; ; time.Sleep(time.Millisecond * 100) {
progress, err := ethservice.BlockChain().TxIndexProgress()
@@ -238,25 +337,44 @@ if err == nil && progress.Done() {
break
}
}
+
+ if enableHistoricalState {
+ // Now that we have a filled DB, swap the pre-Bedrock consensus to OpLegacy,
+ // which does not support re-processing of pre-bedrock data.
+ ethservice.Engine().(*beacon.Beacon).SwapInner(&beacon.OpLegacy{})
+ }
+
return n, blocks
}
-func generateTestChain() []*types.Block {
+func generateTestChain(consensusEngine consensus.Engine, genesis *core.Genesis, length int) []*types.Block {
generate := func(i int, g *core.BlockGen) {
g.OffsetTime(5)
g.SetExtra([]byte("test"))
if i == 1 {
// Test transactions are included in block #2.
+ if genesis.Config.Optimism != nil && genesis.Config.IsBedrock(big.NewInt(1)) {
+ g.AddTx(depositTx)
+ }
g.AddTx(testTx1)
g.AddTx(testTx2)
}
}
- _, blocks, _ := core.GenerateChainWithGenesis(genesis, ethash.NewFaker(), 2, generate)
+ _, blocks, _ := core.GenerateChainWithGenesis(genesis, consensusEngine, length, generate)
return append([]*types.Block{genesis.ToBlock()}, blocks...)
}
+func TestEthClientHistoricalBackend(t *testing.T) {
+ backend, _ := newTestBackend(t, true)
+ client := backend.Attach()
+ defer backend.Close()
+ defer client.Close()
+
+ testHistoricalRPC(t, client)
+}
+
func TestEthClient(t *testing.T) {
- backend, chain := newTestBackend(t)
+ backend, chain := newTestBackend(t, false)
client := backend.Attach()
defer backend.Close()
defer client.Close()
@@ -293,6 +411,9 @@ func(t *testing.T) { testAtFunctions(t, client) },
},
"TransactionSender": {
func(t *testing.T) { testTransactionSender(t, client) },
+ },
+ "EstimateGas": {
+ func(t *testing.T) { testEstimateGas(t, client) },
},
}
@@ -729,6 +850,54 @@ t.Fatal(err)
}
if sender2 != testAddr {
t.Fatal("wrong sender:", sender2)
+ }
+}
+
+func testEstimateGas(t *testing.T, client *rpc.Client) {
+ ec := NewClient(client)
+
+ // EstimateGas
+ msg := ethereum.CallMsg{
+ From: testAddr,
+ To: &common.Address{},
+ Gas: 21000,
+ Value: big.NewInt(1),
+ }
+ gas, err := ec.EstimateGas(context.Background(), msg)
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if gas != 21000 {
+ t.Fatalf("unexpected gas price: %v", gas)
+ }
+}
+
+func testHistoricalRPC(t *testing.T, client *rpc.Client) {
+ ec := NewClient(client)
+
+ // Estimate Gas RPC
+ msg := ethereum.CallMsg{
+ From: testAddr,
+ To: &common.Address{},
+ Gas: 21000,
+ Value: big.NewInt(1),
+ }
+ var res hexutil.Uint64
+ err := client.CallContext(context.Background(), &res, "eth_estimateGas", toCallArg(msg), rpc.BlockNumberOrHashWithNumber(1))
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if res != 12345 {
+ t.Fatalf("invalid result: %d", res)
+ }
+
+ // Call Contract RPC
+ histVal, err := ec.CallContract(context.Background(), msg, big.NewInt(1))
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if string(histVal) != "test" {
+ t.Fatalf("expected %s to equal test", string(histVal))
}
}
diff --git go-ethereum/internal/ethapi/transaction_args_test.go op-geth/internal/ethapi/transaction_args_test.go
index 1b1634b250317604dd22291aca69143177f3fbe6..4dd4a6e101701ea2f6db8e937119388da7e57877 100644
--- go-ethereum/internal/ethapi/transaction_args_test.go
+++ op-geth/internal/ethapi/transaction_args_test.go
@@ -24,20 +24,20 @@ "reflect"
"testing"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/bloombits"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/bloombits"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
// TestSetFeeDefaults tests the logic for filling in default fee values works as expected.
@@ -403,4 +403,6 @@ func (b *backendMock) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
return nil
}
-func (b *backendMock) Engine() consensus.Engine { return nil }
+func (b *backendMock) Engine() consensus.Engine { return nil }
+func (b *backendMock) HistoricalRPCService() *rpc.Client { return nil }
+func (b *backendMock) Genesis() *types.Block { return nil }
Debug API
+15
-12
Fix Debug API block marshaling to include deposits
diff --git go-ethereum/eth/api_debug.go op-geth/eth/api_debug.go
index 05010a3969c61befb62d4bc2f413ddd72609851f..0191e5ca76bfac082e454cb9f70643e005a7c141 100644
--- go-ethereum/eth/api_debug.go
+++ op-geth/eth/api_debug.go
@@ -22,17 +22,17 @@ "errors"
"fmt"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/rpc"
+ "github.com/tenderly/op-geth/trie"
)
// DebugAPI is the collection of Ethereum full node APIs for debugging the
@@ -119,7 +119,10 @@ blockRlp = err.Error() // Hacky, but hey, it works
} else {
blockRlp = fmt.Sprintf("%#x", rlpBytes)
}
- blockJSON = ethapi.RPCMarshalBlock(block, true, true, api.eth.APIBackend.ChainConfig())
+ var err error
+ if blockJSON, err = ethapi.RPCMarshalBlock(ctx, block, true, true, api.eth.APIBackend.ChainConfig(), api.eth.APIBackend); err != nil {
+ blockJSON = map[string]interface{}{"error": err.Error()}
+ }
results = append(results, &BadBlockArgs{
Hash: block.Hash(),
RLP: blockRlp,
Eth gasprice suggestions
+147
-9
gasprice suggestion adjustments to accommodate faster L2 blocks and lower fees.
diff --git go-ethereum/eth/gasprice/gasprice.go op-geth/eth/gasprice/gasprice.go
index b71964981145fa58b7894a2be4637d8a7e2a6c9a..93fe0e2666c273f70a5c5d56d892a8c8bfd12fce 100644
--- go-ethereum/eth/gasprice/gasprice.go
+++ op-geth/eth/gasprice/gasprice.go
@@ -21,14 +21,14 @@ "context"
"math/big"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
"golang.org/x/exp/slices"
)
@@ -37,6 +37,8 @@
var (
DefaultMaxPrice = big.NewInt(500 * params.GWei)
DefaultIgnorePrice = big.NewInt(2 * params.Wei)
+
+ DefaultMinSuggestedPriorityFee = big.NewInt(1e6 * params.Wei) // 0.001 gwei, for Optimism fee suggestion
)
type Config struct {
@@ -47,6 +49,8 @@ MaxBlockHistory uint64
Default *big.Int `toml:",omitempty"`
MaxPrice *big.Int `toml:",omitempty"`
IgnorePrice *big.Int `toml:",omitempty"`
+
+ MinSuggestedPriorityFee *big.Int `toml:",omitempty"` // for Optimism fee suggestion
}
// OracleBackend includes all necessary background APIs for oracle.
@@ -74,6 +78,8 @@ checkBlocks, percentile int
maxHeaderHistory, maxBlockHistory uint64
historyCache *lru.Cache[cacheKey, processedFees]
+
+ minSuggestedPriorityFee *big.Int // for Optimism fee suggestion
}
// NewOracle returns a new gasprice oracle which can recommend suitable
@@ -128,7 +134,7 @@ lastHead = ev.Block.Hash()
}
}()
- return &Oracle{
+ r := &Oracle{
backend: backend,
lastPrice: params.Default,
maxPrice: maxPrice,
@@ -139,6 +145,17 @@ maxHeaderHistory: maxHeaderHistory,
maxBlockHistory: maxBlockHistory,
historyCache: cache,
}
+
+ if backend.ChainConfig().IsOptimism() {
+ r.minSuggestedPriorityFee = params.MinSuggestedPriorityFee
+ if r.minSuggestedPriorityFee == nil || r.minSuggestedPriorityFee.Int64() <= 0 {
+ r.minSuggestedPriorityFee = DefaultMinSuggestedPriorityFee
+ log.Warn("Sanitizing invalid optimism gasprice oracle min priority fee suggestion",
+ "provided", params.MinSuggestedPriorityFee,
+ "updated", r.minSuggestedPriorityFee)
+ }
+ }
+ return r
}
// SuggestTipCap returns a tip cap so that newly created transaction can have a
@@ -168,6 +185,11 @@ oracle.cacheLock.RUnlock()
if headHash == lastHead {
return new(big.Int).Set(lastPrice), nil
}
+
+ if oracle.backend.ChainConfig().IsOptimism() {
+ return oracle.SuggestOptimismPriorityFee(ctx, head, headHash), nil
+ }
+
var (
sent, exp int
number = head.Number.Uint64()
@@ -274,3 +296,9 @@ case result <- results{prices, nil}:
case <-quit:
}
}
+
+type bigIntArray []*big.Int
+
+func (s bigIntArray) Len() int { return len(s) }
+func (s bigIntArray) Less(i, j int) bool { return s[i].Cmp(s[j]) < 0 }
+func (s bigIntArray) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
diff --git go-ethereum/eth/gasprice/optimism-gasprice.go op-geth/eth/gasprice/optimism-gasprice.go
new file mode 100644
index 0000000000000000000000000000000000000000..0cd1bca7f8abce670d649e3a309fc05f9e2ca244
--- /dev/null
+++ op-geth/eth/gasprice/optimism-gasprice.go
@@ -0,0 +1,110 @@
+package gasprice
+
+import (
+ "context"
+ "math/big"
+ "sort"
+
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rpc"
+)
+
+// SuggestOptimismPriorityFee returns a max priority fee value that can be used such that newly
+// created transactions have a very high chance to be included in the following blocks, using a
+// simplified and more predictable algorithm appropriate for chains like Optimism with a single
+// known block builder.
+//
+// In the typical case, which results whenever the last block had room for more transactions, this
+// function returns a minimum suggested priority fee value. Otherwise it returns the higher of this
+// minimum suggestion or 10% over the median effective priority fee from the last block.
+//
+// Rationale: For a chain such as Optimism where there is a single block builder whose behavior is
+// known, we know priority fee (as long as it is non-zero) has no impact on the probability for tx
+// inclusion as long as there is capacity for it in the block. In this case then, there's no reason
+// to return any value higher than some fixed minimum. Blocks typically reach capacity only under
+// extreme events such as airdrops, meaning predicting whether the next block is going to be at
+// capacity is difficult *except* in the case where we're already experiencing the increased demand
+// from such an event. We therefore expect whether the last known block is at capacity to be one of
+// the best predictors of whether the next block is likely to be at capacity. (An even better
+// predictor is to look at the state of the transaction pool, but we want an algorithm that works
+// even if the txpool is private or unavailable.)
+//
+// In the event the next block may be at capacity, the algorithm should allow for average fees to
+// rise in order to reach a market price that appropriately reflects demand. We accomplish this by
+// returning a suggestion that is a significant amount (10%) higher than the median effective
+// priority fee from the previous block.
+func (oracle *Oracle) SuggestOptimismPriorityFee(ctx context.Context, h *types.Header, headHash common.Hash) *big.Int {
+ suggestion := new(big.Int).Set(oracle.minSuggestedPriorityFee)
+
+ // find the maximum gas used by any of the transactions in the block to use as the capacity
+ // margin
+ receipts, err := oracle.backend.GetReceipts(ctx, headHash)
+ if receipts == nil || err != nil {
+ log.Error("failed to get block receipts", "err", err)
+ return suggestion
+ }
+ var maxTxGasUsed uint64
+ for i := range receipts {
+ gu := receipts[i].GasUsed
+ if gu > maxTxGasUsed {
+ maxTxGasUsed = gu
+ }
+ }
+
+ // sanity check the max gas used value
+ if maxTxGasUsed > h.GasLimit {
+ log.Error("found tx consuming more gas than the block limit", "gas", maxTxGasUsed)
+ return suggestion
+ }
+
+ if h.GasUsed+maxTxGasUsed > h.GasLimit {
+ // A block is "at capacity" if, when it is built, there is a pending tx in the txpool that
+ // could not be included because the block's gas limit would be exceeded. Since we don't
+ // have access to the txpool, we instead adopt the following heuristic: consider a block as
+ // at capacity if the total gas consumed by its transactions is within max-tx-gas-used of
+ // the block limit, where max-tx-gas-used is the most gas used by any one transaction
+ // within the block. This heuristic is almost perfectly accurate when transactions always
+ // consume the same amount of gas, but becomes less accurate as tx gas consumption begins
+ // to vary. The typical error is we assume a block is at capacity when it was not because
+ // max-tx-gas-used will in most cases over-estimate the "capacity margin". But it's better
+ // to err on the side of returning a higher-than-needed suggestion than a lower-than-needed
+ // one in order to satisfy our desire for high chance of inclusion and rising fees under
+ // high demand.
+ block, err := oracle.backend.BlockByNumber(ctx, rpc.BlockNumber(h.Number.Int64()))
+ if block == nil || err != nil {
+ log.Error("failed to get last block", "err", err)
+ return suggestion
+ }
+ baseFee := block.BaseFee()
+ txs := block.Transactions()
+ if len(txs) == 0 {
+ log.Error("block was at capacity but doesn't have transactions")
+ return suggestion
+ }
+ tips := bigIntArray(make([]*big.Int, len(txs)))
+ for i := range txs {
+ tips[i] = txs[i].EffectiveGasTipValue(baseFee)
+ }
+ sort.Sort(tips)
+ median := tips[len(tips)/2]
+ newSuggestion := new(big.Int).Add(median, new(big.Int).Div(median, big.NewInt(10)))
+ // use the new suggestion only if it's bigger than the minimum
+ if newSuggestion.Cmp(suggestion) > 0 {
+ suggestion = newSuggestion
+ }
+ }
+
+ // the suggestion should be capped by oracle.maxPrice
+ if suggestion.Cmp(oracle.maxPrice) > 0 {
+ suggestion.Set(oracle.maxPrice)
+ }
+
+ oracle.cacheLock.Lock()
+ oracle.lastHead = headHash
+ oracle.lastPrice = suggestion
+ oracle.cacheLock.Unlock()
+
+ return new(big.Int).Set(suggestion)
+}
API testvector fix
+1
-1
Upstream test of broken behavior; in Optimism, a zero signature is valid (pre-bedrock for deposit-txs), and the chain ID formula on signature data must not be used, or an underflow happens.
diff --git go-ethereum/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json op-geth/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json
index 1d524d6eced19249ab7f1d7beeb04863087e81c1..7087932286ea7facdae1e56caf15e618b5307e71 100644
--- go-ethereum/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json
+++ op-geth/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json
@@ -30,7 +30,7 @@ "to": "0x0d3ab14bbad3d99f4203bd7a11acb94882050e7e",
"transactionIndex": "0x0",
"value": "0x6f",
"type": "0x0",
- "chainId": "0x7fffffffffffffee",
+ "chainId": "0x1",
"v": "0x0",
"r": "0x0",
"s": "0x0"
Geth extras
+59
-24
Extend the tools available in geth to improve external testing and tooling.
Simulated Backend
+59
-24
diff --git go-ethereum/accounts/abi/bind/backends/simulated.go op-geth/accounts/abi/bind/backends/simulated.go
index dfd929695286568a72fcb10a8c671e7b00b8cf22..cb675bd959d6db294e9d8da2edd0822c4843f954 100644
--- go-ethereum/accounts/abi/bind/backends/simulated.go
+++ op-geth/accounts/abi/bind/backends/simulated.go
@@ -19,13 +19,14 @@
import (
"context"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethclient/simulated"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/ethclient/simulated"
)
// SimulatedBackend is a simulated blockchain.
-// Deprecated: use package github.com/ethereum/go-ethereum/ethclient/simulated instead.
+// Deprecated: use package github.com/tenderly/op-geth/ethclient/simulated instead.
type SimulatedBackend struct {
*simulated.Backend
simulated.Client
@@ -42,7 +43,7 @@ //
// A simulated backend always uses chainID 1337.
//
// Deprecated: please use simulated.Backend from package
-// github.com/ethereum/go-ethereum/ethclient/simulated instead.
+// github.com/tenderly/op-geth/ethclient/simulated instead.
func NewSimulatedBackend(alloc types.GenesisAlloc, gasLimit uint64) *SimulatedBackend {
b := simulated.NewBackend(alloc, simulated.WithBlockGasLimit(gasLimit))
return &SimulatedBackend{
@@ -50,3 +51,11 @@ Backend: b,
Client: b.Client(),
}
}
+
+func NewSimulatedBackendFromConfig(cfg ethconfig.Config) *SimulatedBackend {
+ b := simulated.NewBackendFromConfig(cfg)
+ return &SimulatedBackend{
+ Backend: b,
+ Client: b.Client(),
+ }
+}
diff --git go-ethereum/ethclient/simulated/backend.go op-geth/ethclient/simulated/backend.go
index 0c2a0b453c1b2dff518a1d2576c71d176943e9e6..f019a5cf88009561df547f38d4d37fc597524276 100644
--- go-ethereum/ethclient/simulated/backend.go
+++ op-geth/ethclient/simulated/backend.go
@@ -17,22 +17,23 @@
package simulated
import (
+ "errors"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/catalyst"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/eth/filters"
- "github.com/ethereum/go-ethereum/ethclient"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/catalyst"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/eth/filters"
+ "github.com/tenderly/op-geth/ethclient"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
// Client exposes the methods provided by the Ethereum RPC client.
@@ -62,7 +63,7 @@
// Backend is a simulated blockchain. You can use it to test your contracts or
// other code that interacts with the Ethereum chain.
type Backend struct {
- eth *eth.Ethereum
+ node *node.Node
beacon *catalyst.SimulatedBeacon
client simClient
}
@@ -102,6 +103,27 @@ }
return sim
}
+func NewBackendFromConfig(conf ethconfig.Config) *Backend {
+ // Setup the node object
+ nodeConf := node.DefaultConfig
+ nodeConf.DataDir = ""
+ nodeConf.P2P = p2p.Config{NoDiscovery: true}
+ stack, err := node.New(&nodeConf)
+ if err != nil {
+ // This should never happen, if it does, please open an issue
+ panic(err)
+ }
+
+ conf.SyncMode = downloader.FullSync
+ conf.TxPool.NoLocals = true
+ sim, err := newWithNode(stack, &conf, 0)
+ if err != nil {
+ // This should never happen, if it does, please open an issue
+ panic(err)
+ }
+ return sim
+}
+
// newWithNode sets up a simulated backend on an existing node. The provided node
// must not be started and will be started by this method.
func newWithNode(stack *node.Node, conf *eth.Config, blockPeriod uint64) (*Backend, error) {
@@ -129,7 +151,7 @@ if err := beacon.Fork(backend.BlockChain().GetCanonicalHash(0)); err != nil {
return nil, err
}
return &Backend{
- eth: backend,
+ node: stack,
beacon: beacon,
client: simClient{ethclient.NewClient(stack.Attach())},
}, nil
@@ -142,12 +164,16 @@ if n.client.Client != nil {
n.client.Close()
n.client = simClient{}
}
+ var err error
if n.beacon != nil {
- err := n.beacon.Stop()
+ err = n.beacon.Stop()
n.beacon = nil
- return err
}
- return nil
+ if n.node != nil {
+ err = errors.Join(err, n.node.Close())
+ n.node = nil
+ }
+ return err
}
// Commit seals a block and moves the chain forward to a new empty block.
Hardware wallet support
+14
-10
Extend Ledger wallet support for newer devices on Macos
Fix Ledger discoverability
+14
-10
diff --git go-ethereum/accounts/usbwallet/hub.go op-geth/accounts/usbwallet/hub.go
index e67942dbc1072ea952c204c1f30f3803dbf8e567..795ec6fe19a6dde8a4da7505180ddf6bd6120d16 100644
--- go-ethereum/accounts/usbwallet/hub.go
+++ op-geth/accounts/usbwallet/hub.go
@@ -23,10 +23,12 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
+ "golang.org/x/exp/slices"
+
"github.com/karalabe/usb"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
)
// LedgerScheme is the protocol scheme prefixing account and wallet URLs.
@@ -48,7 +50,7 @@ type Hub struct {
scheme string // Protocol scheme prefixing account and wallet URLs.
vendorID uint16 // USB vendor identifier used for device discovery
productIDs []uint16 // USB product identifiers used for device discovery
- usageID uint16 // USB usage page identifier used for macOS device discovery
+ usageIDs []uint16 // USB usage page identifier used for macOS device discovery
endpointID int // USB endpoint identifier used for non-macOS device discovery
makeDriver func(log.Logger) driver // Factory method to construct a vendor specific driver
@@ -93,22 +95,22 @@ 0x1011, /* HID + WebUSB Ledger Nano S */
0x4011, /* HID + WebUSB Ledger Nano X */
0x5011, /* HID + WebUSB Ledger Nano S Plus */
0x6011, /* HID + WebUSB Ledger Nano FTS */
- }, 0xffa0, 0, newLedgerDriver)
+ }, []uint16{0xffa0, 0}, 2, newLedgerDriver)
}
// NewTrezorHubWithHID creates a new hardware wallet manager for Trezor devices.
func NewTrezorHubWithHID() (*Hub, error) {
- return newHub(TrezorScheme, 0x534c, []uint16{0x0001 /* Trezor HID */}, 0xff00, 0, newTrezorDriver)
+ return newHub(TrezorScheme, 0x534c, []uint16{0x0001 /* Trezor HID */}, []uint16{0xff00}, 0, newTrezorDriver)
}
// NewTrezorHubWithWebUSB creates a new hardware wallet manager for Trezor devices with
// firmware version > 1.8.0
func NewTrezorHubWithWebUSB() (*Hub, error) {
- return newHub(TrezorScheme, 0x1209, []uint16{0x53c1 /* Trezor WebUSB */}, 0xffff /* No usage id on webusb, don't match unset (0) */, 0, newTrezorDriver)
+ return newHub(TrezorScheme, 0x1209, []uint16{0x53c1 /* Trezor WebUSB */}, []uint16{0xffff} /* No usage id on webusb, don't match unset (0) */, 0, newTrezorDriver)
}
// newHub creates a new hardware wallet manager for generic USB devices.
-func newHub(scheme string, vendorID uint16, productIDs []uint16, usageID uint16, endpointID int, makeDriver func(log.Logger) driver) (*Hub, error) {
+func newHub(scheme string, vendorID uint16, productIDs []uint16, usageIDs []uint16, endpointID int, makeDriver func(log.Logger) driver) (*Hub, error) {
if !usb.Supported() {
return nil, errors.New("unsupported platform")
}
@@ -116,7 +118,7 @@ hub := &Hub{
scheme: scheme,
vendorID: vendorID,
productIDs: productIDs,
- usageID: usageID,
+ usageIDs: usageIDs,
endpointID: endpointID,
makeDriver: makeDriver,
quit: make(chan chan error),
@@ -186,7 +188,9 @@
for _, info := range infos {
for _, id := range hub.productIDs {
// Windows and Macos use UsageID matching, Linux uses Interface matching
- if info.ProductID == id && (info.UsagePage == hub.usageID || info.Interface == hub.endpointID) {
+ if info.ProductID == id &&
+ info.Path != "" &&
+ (slices.Contains(hub.usageIDs, info.UsagePage) || info.Interface == hub.endpointID) {
devices = append(devices, info)
break
}
Testing
+3253
-1433
Additional or modified tests, not already captured by the above diff
diff --git go-ethereum/accounts/abi/abi_test.go op-geth/accounts/abi/abi_test.go
index bc76df0dc2649588bed2782dfd7f090f00012e62..bb39d0d98987640d09f262facfb1693ade43769c 100644
--- go-ethereum/accounts/abi/abi_test.go
+++ op-geth/accounts/abi/abi_test.go
@@ -26,9 +26,9 @@ "reflect"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
)
const jsondata = `
diff --git go-ethereum/accounts/abi/bind/base_test.go op-geth/accounts/abi/bind/base_test.go
index f7eb7d14d3e2e4f6c774fe9e4edc4f76802b3e97..f4bfcd56640cad5b37ce2d8831585d9d8dd4af11 100644
--- go-ethereum/accounts/abi/bind/base_test.go
+++ op-geth/accounts/abi/bind/base_test.go
@@ -24,15 +24,15 @@ "reflect"
"strings"
"testing"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/stretchr/testify/assert"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts/abi"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
)
func mockSign(addr common.Address, tx *types.Transaction) (*types.Transaction, error) { return tx, nil }
diff --git go-ethereum/accounts/abi/bind/bind_test.go op-geth/accounts/abi/bind/bind_test.go
index a390a3c47c7e24019c1159affa3016420b77c00b..431a8107e4e2dc49368504aaeb7137c79c31f1e2 100644
--- go-ethereum/accounts/abi/bind/bind_test.go
+++ op-geth/accounts/abi/bind/bind_test.go
@@ -25,7 +25,7 @@ "runtime"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
var bindTests = []struct {
@@ -46,7 +46,7 @@ `Empty`,
`contract NilContract {}`,
[]string{`606060405260068060106000396000f3606060405200`},
[]string{`[]`},
- `"github.com/ethereum/go-ethereum/common"`,
+ `"github.com/tenderly/op-geth/common"`,
`
if b, err := NewEmpty(common.Address{}, nil); b == nil || err != nil {
t.Fatalf("combined binding (%v) nil or error (%v) not nil", b, nil)
@@ -69,7 +69,7 @@ `Token`,
`https://ethereum.org/token`,
[]string{`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`},
[]string{`[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"success","type":"bool"}],"type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"},{"name":"_extraData","type":"bytes"}],"name":"approveAndCall","outputs":[{"name":"success","type":"bool"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"spentAllowance","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"inputs":[{"name":"initialSupply","type":"uint256"},{"name":"tokenName","type":"string"},{"name":"decimalUnits","type":"uint8"},{"name":"tokenSymbol","type":"string"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Transfer","type":"event"}]`},
- `"github.com/ethereum/go-ethereum/common"`,
+ `"github.com/tenderly/op-geth/common"`,
`
if b, err := NewToken(common.Address{}, nil); b == nil || err != nil {
t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
@@ -85,7 +85,7 @@ `Crowdsale`,
`https://ethereum.org/crowdsale`,
[]string{`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`},
[]string{`[{"constant":false,"inputs":[],"name":"checkGoalReached","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"deadline","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"beneficiary","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[],"name":"tokenReward","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[],"name":"fundingGoal","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"amountRaised","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"price","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"funders","outputs":[{"name":"addr","type":"address"},{"name":"amount","type":"uint256"}],"type":"function"},{"inputs":[{"name":"ifSuccessfulSendTo","type":"address"},{"name":"fundingGoalInEthers","type":"uint256"},{"name":"durationInMinutes","type":"uint256"},{"name":"etherCostOfEachToken","type":"uint256"},{"name":"addressOfTokenUsedAsReward","type":"address"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"backer","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"isContribution","type":"bool"}],"name":"FundTransfer","type":"event"}]`},
- `"github.com/ethereum/go-ethereum/common"`,
+ `"github.com/tenderly/op-geth/common"`,
`
if b, err := NewCrowdsale(common.Address{}, nil); b == nil || err != nil {
t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
@@ -101,7 +101,7 @@ `DAO`,
`https://ethereum.org/dao`,
[]string{`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`},
[]string{`[{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"proposals","outputs":[{"name":"recipient","type":"address"},{"name":"amount","type":"uint256"},{"name":"description","type":"string"},{"name":"votingDeadline","type":"uint256"},{"name":"executed","type":"bool"},{"name":"proposalPassed","type":"bool"},{"name":"numberOfVotes","type":"uint256"},{"name":"currentResult","type":"int256"},{"name":"proposalHash","type":"bytes32"}],"type":"function"},{"constant":false,"inputs":[{"name":"proposalNumber","type":"uint256"},{"name":"transactionBytecode","type":"bytes"}],"name":"executeProposal","outputs":[{"name":"result","type":"int256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"memberId","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"numProposals","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"members","outputs":[{"name":"member","type":"address"},{"name":"canVote","type":"bool"},{"name":"name","type":"string"},{"name":"memberSince","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"debatingPeriodInMinutes","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"minimumQuorum","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":false,"inputs":[{"name":"targetMember","type":"address"},{"name":"canVote","type":"bool"},{"name":"memberName","type":"string"}],"name":"changeMembership","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"majorityMargin","outputs":[{"name":"","type":"int256"}],"type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"},{"name":"etherAmount","type":"uint256"},{"name":"JobDescription","type":"string"},{"name":"transactionBytecode","type":"bytes"}],"name":"newProposal","outputs":[{"name":"proposalID","type":"uint256"}],"type":"function"},{"constant":false,"inputs":[{"name":"minimumQuorumForProposals","type":"uint256"},{"name":"minutesForDebate","type":"uint256"},{"name":"marginOfVotesForMajority","type":"int256"}],"name":"changeVotingRules","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"proposalNumber","type":"uint256"},{"name":"supportsProposal","type":"bool"},{"name":"justificationText","type":"string"}],"name":"vote","outputs":[{"name":"voteID","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"proposalNumber","type":"uint256"},{"name":"beneficiary","type":"address"},{"name":"etherAmount","type":"uint256"},{"name":"transactionBytecode","type":"bytes"}],"name":"checkProposalCode","outputs":[{"name":"codeChecksOut","type":"bool"}],"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"type":"function"},{"inputs":[{"name":"minimumQuorumForProposals","type":"uint256"},{"name":"minutesForDebate","type":"uint256"},{"name":"marginOfVotesForMajority","type":"int256"},{"name":"congressLeader","type":"address"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"proposalID","type":"uint256"},{"indexed":false,"name":"recipient","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"description","type":"string"}],"name":"ProposalAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"proposalID","type":"uint256"},{"indexed":false,"name":"position","type":"bool"},{"indexed":false,"name":"voter","type":"address"},{"indexed":false,"name":"justification","type":"string"}],"name":"Voted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"proposalID","type":"uint256"},{"indexed":false,"name":"result","type":"int256"},{"indexed":false,"name":"quorum","type":"uint256"},{"indexed":false,"name":"active","type":"bool"}],"name":"ProposalTallied","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"member","type":"address"},{"indexed":false,"name":"isMember","type":"bool"}],"name":"MembershipChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"minimumQuorum","type":"uint256"},{"indexed":false,"name":"debatingPeriodInMinutes","type":"uint256"},{"indexed":false,"name":"majorityMargin","type":"int256"}],"name":"ChangeOfRules","type":"event"}]`},
- `"github.com/ethereum/go-ethereum/common"`,
+ `"github.com/tenderly/op-geth/common"`,
`
if b, err := NewDAO(common.Address{}, nil); b == nil || err != nil {
t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
@@ -128,7 +128,7 @@ `},
`
"fmt"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
`,
`if b, err := NewInputChecker(common.Address{}, nil); b == nil || err != nil {
t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
@@ -166,7 +166,7 @@ `},
`
"fmt"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
`,
`if b, err := NewOutputChecker(common.Address{}, nil); b == nil || err != nil {
t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
@@ -207,7 +207,7 @@ "fmt"
"math/big"
"reflect"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
`,
`if e, err := NewEventChecker(common.Address{}, nil); e == nil || err != nil {
t.Fatalf("binding (%v) nil or error (%v) not nil", e, nil)
@@ -287,10 +287,10 @@ []string{`[{"constant":true,"inputs":[],"name":"transactString","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":true,"inputs":[],"name":"deployString","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":false,"inputs":[{"name":"str","type":"string"}],"name":"transact","outputs":[],"type":"function"},{"inputs":[{"name":"str","type":"string"}],"type":"constructor"}]`},
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -343,10 +343,10 @@ []string{`[{"constant":true,"inputs":[],"name":"getter","outputs":[{"name":"","type":"string"},{"name":"","type":"int256"},{"name":"","type":"bytes32"}],"type":"function"}]`},
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -389,10 +389,10 @@ []string{`[{"constant":true,"inputs":[],"name":"tuple","outputs":[{"name":"a","type":"string"},{"name":"b","type":"int256"},{"name":"c","type":"bytes32"}],"type":"function"}]`},
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -446,11 +446,11 @@ `
"math/big"
"reflect"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -495,10 +495,10 @@ []string{`[{"constant":true,"inputs":[],"name":"caller","outputs":[{"name":"","type":"address"}],"type":"function"}]`},
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -562,10 +562,10 @@ []string{`[{"inputs":[],"name":"F","outputs":[{"components":[{"internalType":"bytes32","name":"B","type":"bytes32"}],"internalType":"structStructs.A[]","name":"a","type":"tuple[]"},{"internalType":"uint256[]","name":"c","type":"uint256[]"},{"internalType":"bool[]","name":"d","type":"bool[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"G","outputs":[{"components":[{"internalType":"bytes32","name":"B","type":"bytes32"}],"internalType":"structStructs.A[]","name":"a","type":"tuple[]"}],"stateMutability":"view","type":"function"}]`},
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -607,10 +607,10 @@ `,
[]string{`6060604052609f8060106000396000f3606060405260e060020a6000350463f97a60058114601a575b005b600060605260c0604052600d60809081527f4920646f6e27742065786973740000000000000000000000000000000000000060a052602060c0908152600d60e081905281906101009060a09080838184600060046012f15050815172ffffffffffffffffffffffffffffffffffffff1916909152505060405161012081900392509050f3`},
[]string{`[{"constant":true,"inputs":[],"name":"String","outputs":[{"name":"","type":"string"}],"type":"function"}]`},
`
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
`,
`
// Create a simulator and wrap a non-deployed contract
@@ -646,10 +646,10 @@ `,
[]string{`6080604052348015600f57600080fd5b5060888061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063d5f6622514602d575b600080fd5b6033604c565b6040805192835260208301919091528051918290030190f35b600a809156fea264697066735822beefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef64736f6c6343decafe0033`},
[]string{`[{"inputs":[],"name":"Struct","outputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"}],"stateMutability":"pure","type":"function"}]`},
`
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
`,
`
// Create a simulator and wrap a non-deployed contract
@@ -694,10 +694,10 @@ []string{`[{"constant":false,"inputs":[{"name":"value","type":"string"}],"name":"SetField","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"field","outputs":[{"name":"","type":"string"}],"type":"function"}]`},
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -743,11 +743,11 @@ []string{`[{"constant":true,"inputs":[],"name":"callFrom","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"}]`},
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -819,10 +819,10 @@ `
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -912,11 +912,11 @@ `
"math/big"
"time"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -1103,10 +1103,10 @@ []string{`[{"constant":false,"inputs":[{"name":"arr","type":"uint64[3][4][5]"}],"name":"storeDeepUintArray","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"retrieveDeepArray","outputs":[{"name":"","type":"uint64[3][4][5]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"name":"deepUint64Array","outputs":[{"name":"","type":"uint64"}],"payable":false,"stateMutability":"view","type":"function"}]`},
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -1238,10 +1238,10 @@ `
"math/big"
"reflect"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
@@ -1380,10 +1380,10 @@ },
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -1446,10 +1446,10 @@ `
"math/big"
"time"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Initialize test accounts
@@ -1534,10 +1534,10 @@ []string{`[{"constant":true,"inputs":[],"name":"MyVar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_myVar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]`},
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/core/types"
`,
`
// Initialize test accounts
@@ -1597,10 +1597,10 @@ },
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/core/types"
`,
`
key, _ := crypto.GenerateKey()
@@ -1659,10 +1659,10 @@ []string{`[{"inputs": [],"name": "PureFunc","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "pure","type": "function"},{"inputs": [],"name": "ViewFunc","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "view","type": "function"}]`},
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
// Generate a new random account and a funded simulator
@@ -1720,10 +1720,10 @@ `
"bytes"
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
`,
`
key, _ := crypto.GenerateKey()
@@ -1808,11 +1808,11 @@ []string{`[{"anonymous":false,"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"}],"indexed":false,"internalType":"struct Test.MyStruct","name":"s","type":"tuple"}],"name":"StructEvent","type":"event"},{"inputs":[],"name":"TestEvent","outputs":[],"stateMutability":"nonpayable","type":"function"}]`},
`
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/ethconfig"
`,
`
var (
@@ -1879,11 +1879,11 @@ `
"context"
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/ethconfig"
`,
`
var (
@@ -1932,11 +1932,11 @@ imports: `
"context"
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/ethconfig"
`,
tester: `
var (
@@ -1981,11 +1981,11 @@ imports: `
"context"
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/ethconfig"
`,
tester: `
var (
@@ -2022,11 +2022,11 @@ imports: `
"context"
"math/big"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/accounts/abi/bind/backends"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/ethconfig"
`,
tester: `
var (
@@ -2060,7 +2060,7 @@ `,
bytecode: []string{"0x6080604052348015600f57600080fd5b5060958061001e6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c80639d993132146041578063d02767c7146049578063ffa02795146051575b600080fd5b60476059565b005b604f605b565b005b6057605d565b005b565b565b56fea26469706673582212200382ca602dff96a7e2ba54657985e2b4ac423a56abe4a1f0667bc635c4d4371f64736f6c63430008110033"},
abi: []string{`[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_param","type":"address"}],"name":"_1TestEvent","type":"event"},{"inputs":[],"name":"_1test","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"__1test","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"__2test","outputs":[],"stateMutability":"pure","type":"function"}]`},
imports: `
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
`,
tester: `
if b, err := NewNumericMethodName(common.Address{}, nil); b == nil || err != nil {
@@ -2128,7 +2128,7 @@ if out, err := moder.CombinedOutput(); err != nil {
t.Fatalf("failed to convert binding test to modules: %v\n%s", err, out)
}
pwd, _ := os.Getwd()
- replacer := exec.Command(gocmd, "mod", "edit", "-x", "-require", "github.com/ethereum/go-ethereum@v0.0.0", "-replace", "github.com/ethereum/go-ethereum="+filepath.Join(pwd, "..", "..", "..")) // Repo root
+ replacer := exec.Command(gocmd, "mod", "edit", "-x", "-require", "github.com/tenderly/op-geth@v0.0.0", "-replace", "github.com/tenderly/op-geth="+filepath.Join(pwd, "..", "..", "..")) // Repo root
replacer.Dir = pkg
if out, err := replacer.CombinedOutput(); err != nil {
t.Fatalf("failed to replace binding test dependency to current source tree: %v\n%s", err, out)
diff --git go-ethereum/accounts/abi/bind/util_test.go op-geth/accounts/abi/bind/util_test.go
index 592465f2acfb406d9d5fcef70a30284082affff4..7d7eb434de8f9b65b9b53498ba7310724b3b3a97 100644
--- go-ethereum/accounts/abi/bind/util_test.go
+++ op-geth/accounts/abi/bind/util_test.go
@@ -23,12 +23,12 @@ "math/big"
"testing"
"time"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethclient/simulated"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethclient/simulated"
+ "github.com/tenderly/op-geth/params"
)
var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
diff --git go-ethereum/accounts/abi/event_test.go op-geth/accounts/abi/event_test.go
index fffe28ea63a42515ae706a3b666d7b7798ce527c..6fc4e4c1323f870983efe50d16e80341b8581fab 100644
--- go-ethereum/accounts/abi/event_test.go
+++ op-geth/accounts/abi/event_test.go
@@ -25,10 +25,10 @@ "reflect"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
)
var jsonEventTransfer = []byte(`{
diff --git go-ethereum/accounts/abi/pack_test.go op-geth/accounts/abi/pack_test.go
index 00bdae469e211a787c83970450a87b7853514391..425f3a5a830a9c0f5f6a62845e0d9dc40c880c82 100644
--- go-ethereum/accounts/abi/pack_test.go
+++ op-geth/accounts/abi/pack_test.go
@@ -27,7 +27,7 @@ "strconv"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// TestPack tests the general pack/unpack tests in packing_test.go
diff --git go-ethereum/accounts/abi/packing_test.go op-geth/accounts/abi/packing_test.go
index eae3b0df20562372b4e739ba0e72559c0d19bd96..ea6a25b2a34b7dd6bbfdd04ccd8a07c319dd4484 100644
--- go-ethereum/accounts/abi/packing_test.go
+++ op-geth/accounts/abi/packing_test.go
@@ -19,7 +19,7 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
type packUnpackTest struct {
@@ -375,7 +375,7 @@ {
def: `[{"type": "bytes"}]`,
packed: "0000000000000000000000000000000000000000000000000000000000000020" +
"0000000000000000000000000000000000000000000000000000000000000020" +
- "0100000000000000000000000000000000000000000000000000000000000000",
+ "0100000000000000000000000000000000000000000000000000000000000000", //nolint:all
unpacked: common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
},
{
@@ -476,7 +476,7 @@ {
def: `[{"type": "int256[3]"}]`,
packed: "0000000000000000000000000000000000000000000000000000000000000001" +
"0000000000000000000000000000000000000000000000000000000000000002" +
- "0000000000000000000000000000000000000000000000000000000000000003",
+ "0000000000000000000000000000000000000000000000000000000000000003", //nolint:all
unpacked: [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)},
},
// multi dimensional, if these pass, all types that don't require length prefix should pass
@@ -536,7 +536,7 @@ {
def: `[{"type": "uint8[][2]"}]`,
packed: "0000000000000000000000000000000000000000000000000000000000000020" +
"0000000000000000000000000000000000000000000000000000000000000040" +
- "0000000000000000000000000000000000000000000000000000000000000080" +
+ "0000000000000000000000000000000000000000000000000000000000000080" + //nolint:all
"0000000000000000000000000000000000000000000000000000000000000001" +
"0000000000000000000000000000000000000000000000000000000000000001" +
"0000000000000000000000000000000000000000000000000000000000000001" +
@@ -801,7 +801,7 @@ "0000000000000000000000000000000000000000000000000000000000000002" + // len(array[0]) = 2
"0100000000000000000000000000000000000000000000000000000000000000" + // array[0][0]
"0200000000000000000000000000000000000000000000000000000000000000" + // array[0][1]
"0000000000000000000000000000000000000000000000000000000000000003" + // len(array[1]) = 3
- "0300000000000000000000000000000000000000000000000000000000000000" + // array[1][0]
+ "0300000000000000000000000000000000000000000000000000000000000000" + //nolint:all // array[1][0]
"0400000000000000000000000000000000000000000000000000000000000000" + // array[1][1]
"0500000000000000000000000000000000000000000000000000000000000000", // array[1][2]
},
@@ -845,7 +845,7 @@ E [2][3][32]byte
}{1, big.NewInt(1), big.NewInt(-1), true, [2][3][32]byte{{{1}, {2}, {3}}, {{3}, {4}, {5}}}},
packed: "0000000000000000000000000000000000000000000000000000000000000001" + // struct[a]
"0000000000000000000000000000000000000000000000000000000000000001" + // struct[b]
- "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // struct[c]
+ "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + //nolint:all // struct[c]
"0000000000000000000000000000000000000000000000000000000000000001" + // struct[d]
"0100000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[0][0]
"0200000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[0][1]
diff --git go-ethereum/accounts/abi/topics_test.go op-geth/accounts/abi/topics_test.go
index 9e1efd382160ed0157a7bc3c89415e76df5cf48a..3e81706c71bfb2af667b7bacf202a9aa23d26649 100644
--- go-ethereum/accounts/abi/topics_test.go
+++ op-geth/accounts/abi/topics_test.go
@@ -22,8 +22,8 @@ "math/big"
"reflect"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
)
func TestMakeTopics(t *testing.T) {
diff --git go-ethereum/accounts/abi/type_test.go op-geth/accounts/abi/type_test.go
index ae69872ad8e0cadad2bd5f6de5a449dc4f4a38c0..ecd7a967784e01ef8b8d5f7e13e68011c7bf0928 100644
--- go-ethereum/accounts/abi/type_test.go
+++ op-geth/accounts/abi/type_test.go
@@ -22,7 +22,7 @@ "reflect"
"testing"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// typeWithoutStringer is a alias for the Type type which simply doesn't implement
diff --git go-ethereum/accounts/abi/unpack_test.go op-geth/accounts/abi/unpack_test.go
index 29891ec0a411f625f4b74fc92bf750b37476b474..458ac193f91b254e9e82a90ad1933e1d71368779 100644
--- go-ethereum/accounts/abi/unpack_test.go
+++ op-geth/accounts/abi/unpack_test.go
@@ -27,8 +27,8 @@ "strconv"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
"github.com/stretchr/testify/require"
+ "github.com/tenderly/op-geth/common"
)
// TestUnpack tests the general pack/unpack tests in packing_test.go
diff --git go-ethereum/accounts/accounts_test.go op-geth/accounts/accounts_test.go
index 2c4138aa78047041f5a5275e372c02edcb445c0b..b94fde915fa9ef173277a33bca826843c55adecf 100644
--- go-ethereum/accounts/accounts_test.go
+++ op-geth/accounts/accounts_test.go
@@ -20,7 +20,7 @@ import (
"bytes"
"testing"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common/hexutil"
)
func TestTextHash(t *testing.T) {
diff --git go-ethereum/accounts/keystore/account_cache_test.go op-geth/accounts/keystore/account_cache_test.go
index 48a238048fec9171334c79576286de688a6050d4..0d3c14b84b64c422e9623c1d239557ce0e639ae7 100644
--- go-ethereum/accounts/keystore/account_cache_test.go
+++ op-geth/accounts/keystore/account_cache_test.go
@@ -28,8 +28,8 @@ "time"
"github.com/cespare/cp"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/accounts/keystore/keystore_test.go op-geth/accounts/keystore/keystore_test.go
index c9a23eddd6cac8308624b0e590da30d413ef5bf0..3761da8984b195b68b44a0ceb4814c3962b761f9 100644
--- go-ethereum/accounts/keystore/keystore_test.go
+++ op-geth/accounts/keystore/keystore_test.go
@@ -26,10 +26,10 @@ "sync/atomic"
"testing"
"time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/event"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/event"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/accounts/keystore/passphrase_test.go op-geth/accounts/keystore/passphrase_test.go
index 20ec0f5519f7df42cb9bc707b87c133eb97c7ec6..cf42cca2775162600c52286dca427bc63cfeedad 100644
--- go-ethereum/accounts/keystore/passphrase_test.go
+++ op-geth/accounts/keystore/passphrase_test.go
@@ -20,7 +20,7 @@ import (
"os"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
const (
diff --git go-ethereum/accounts/keystore/plain_test.go op-geth/accounts/keystore/plain_test.go
index 737eb7fd61bd9c2885ed37797d4b3be2114ce138..0319e1d7c2a77735eb88629f054f782b00052284 100644
--- go-ethereum/accounts/keystore/plain_test.go
+++ op-geth/accounts/keystore/plain_test.go
@@ -25,8 +25,8 @@ "reflect"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
)
func tmpKeyStoreIface(t *testing.T, encrypted bool) (dir string, ks keyStore) {
diff --git go-ethereum/beacon/light/committee_chain_test.go op-geth/beacon/light/committee_chain_test.go
index 60ea2a0efdbfa4d5a142edeb56a421654dcecd26..d18eeecdd0317365146875dc5ab099bd695310e3 100644
--- go-ethereum/beacon/light/committee_chain_test.go
+++ op-geth/beacon/light/committee_chain_test.go
@@ -21,10 +21,10 @@ "crypto/rand"
"testing"
"time"
- "github.com/ethereum/go-ethereum/beacon/params"
- "github.com/ethereum/go-ethereum/beacon/types"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/ethdb/memorydb"
+ "github.com/tenderly/op-geth/beacon/params"
+ "github.com/tenderly/op-geth/beacon/types"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/ethdb/memorydb"
)
var (
diff --git go-ethereum/cmd/clef/run_test.go op-geth/cmd/clef/run_test.go
index 5fa6e02e14711d02bb35ddc560d932504c97b8c5..ad01b8618ea89727f25778bb08ceba1922bfcda7 100644
--- go-ethereum/cmd/clef/run_test.go
+++ op-geth/cmd/clef/run_test.go
@@ -21,8 +21,8 @@ "fmt"
"os"
"testing"
- "github.com/ethereum/go-ethereum/internal/cmdtest"
- "github.com/ethereum/go-ethereum/internal/reexec"
+ "github.com/tenderly/op-geth/internal/cmdtest"
+ "github.com/tenderly/op-geth/internal/reexec"
)
const registeredName = "clef-test"
diff --git go-ethereum/cmd/devp2p/internal/ethtest/chain_test.go op-geth/cmd/devp2p/internal/ethtest/chain_test.go
index 62bd6d26eae74f5818003f27abede217e81a4532..b351b7b508682d16f72c246087261bef0d0c1c04 100644
--- go-ethereum/cmd/devp2p/internal/ethtest/chain_test.go
+++ op-geth/cmd/devp2p/internal/ethtest/chain_test.go
@@ -21,10 +21,10 @@ "path/filepath"
"strconv"
"testing"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/p2p"
"github.com/stretchr/testify/assert"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/p2p"
)
// TestEthProtocolNegotiation tests whether the test suite
diff --git go-ethereum/cmd/devp2p/internal/ethtest/suite_test.go op-geth/cmd/devp2p/internal/ethtest/suite_test.go
index ad73bc9f90e7514139115f4284f3f0d664feb99a..246005f4e133b7979aa6fa5778570c23b27019f7 100644
--- go-ethereum/cmd/devp2p/internal/ethtest/suite_test.go
+++ op-geth/cmd/devp2p/internal/ethtest/suite_test.go
@@ -24,14 +24,14 @@ "path"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/catalyst"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/internal/utesting"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/catalyst"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/internal/utesting"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
)
func makeJWTSecret() (string, [32]byte, error) {
diff --git go-ethereum/cmd/ethkey/run_test.go op-geth/cmd/ethkey/run_test.go
index 73506e5da14752a0b9e59754e1664c5daebf199b..132b0d7b0fb4c61c7aea47af6e0cd502c0a130b6 100644
--- go-ethereum/cmd/ethkey/run_test.go
+++ op-geth/cmd/ethkey/run_test.go
@@ -21,8 +21,8 @@ "fmt"
"os"
"testing"
- "github.com/ethereum/go-ethereum/internal/cmdtest"
- "github.com/ethereum/go-ethereum/internal/reexec"
+ "github.com/tenderly/op-geth/internal/cmdtest"
+ "github.com/tenderly/op-geth/internal/reexec"
)
type testEthkey struct {
diff --git go-ethereum/cmd/evm/t8n_test.go op-geth/cmd/evm/t8n_test.go
index ad36540de56c063192c51bfe5e6f9cab81088650..007bcc73df600cfd42a5ce05b5034e6f4f7299fc 100644
--- go-ethereum/cmd/evm/t8n_test.go
+++ op-geth/cmd/evm/t8n_test.go
@@ -24,9 +24,9 @@ "reflect"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/cmd/evm/internal/t8ntool"
- "github.com/ethereum/go-ethereum/internal/cmdtest"
- "github.com/ethereum/go-ethereum/internal/reexec"
+ "github.com/tenderly/op-geth/cmd/evm/internal/t8ntool"
+ "github.com/tenderly/op-geth/internal/cmdtest"
+ "github.com/tenderly/op-geth/internal/reexec"
)
func TestMain(m *testing.M) {
diff --git go-ethereum/cmd/geth/accountcmd_test.go op-geth/cmd/geth/accountcmd_test.go
index ea3a7c3b647c83126ba66c1f277b6a60a6eddd34..72cc789ef0fdaee58987ad28dc85ac4fa0b57736 100644
--- go-ethereum/cmd/geth/accountcmd_test.go
+++ op-geth/cmd/geth/accountcmd_test.go
@@ -249,7 +249,7 @@ Fatal: Failed to unlock account f466859ead1932d743d622cb74fc058882e8648a (could not decrypt key with given password)
`)
}
-// https://github.com/ethereum/go-ethereum/issues/1785
+// https://github.com/tenderly/op-geth/issues/1785
func TestUnlockFlagMultiIndex(t *testing.T) {
t.Parallel()
geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
diff --git go-ethereum/cmd/geth/consolecmd_test.go op-geth/cmd/geth/consolecmd_test.go
index ef6ef5f2883616d4392aa629ae56db8f48ba3e16..2c5cd9cc09f2e1ceec817e4c207f6cd842464125 100644
--- go-ethereum/cmd/geth/consolecmd_test.go
+++ op-geth/cmd/geth/consolecmd_test.go
@@ -26,7 +26,7 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/params"
)
const (
diff --git go-ethereum/cmd/geth/exportcmd_test.go op-geth/cmd/geth/exportcmd_test.go
index 9570b1ffd27a2f12774fc85835d8abd444e27e6d..bedf6c58d0c52ff19e2f89b0c755ee340c98821a 100644
--- go-ethereum/cmd/geth/exportcmd_test.go
+++ op-geth/cmd/geth/exportcmd_test.go
@@ -22,7 +22,7 @@ "fmt"
"os"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// TestExport does a basic test of "geth export", exporting the test-genesis.
diff --git go-ethereum/cmd/geth/logging_test.go op-geth/cmd/geth/logging_test.go
index b5ce03f4b8db192a4b66bada625846f82c627221..0218f144a1ea365c2aa429560eda2b8538ccf7d6 100644
--- go-ethereum/cmd/geth/logging_test.go
+++ op-geth/cmd/geth/logging_test.go
@@ -30,7 +30,7 @@ "os/exec"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/internal/reexec"
+ "github.com/tenderly/op-geth/internal/reexec"
)
func runSelf(args ...string) ([]byte, error) {
diff --git go-ethereum/cmd/geth/run_test.go op-geth/cmd/geth/run_test.go
index 1d32880325d4a42bce3d5d15240372b62181afc6..e42db6e47d7cdd9aefea7eae52663998bcbdfee7 100644
--- go-ethereum/cmd/geth/run_test.go
+++ op-geth/cmd/geth/run_test.go
@@ -23,9 +23,9 @@ "os"
"testing"
"time"
- "github.com/ethereum/go-ethereum/internal/cmdtest"
- "github.com/ethereum/go-ethereum/internal/reexec"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/internal/cmdtest"
+ "github.com/tenderly/op-geth/internal/reexec"
+ "github.com/tenderly/op-geth/rpc"
)
type testgeth struct {
diff --git go-ethereum/cmd/rlpdump/rlpdump_test.go op-geth/cmd/rlpdump/rlpdump_test.go
index 4b0ae680acaaa987fc8dc655f62157d60510b6ac..34be359f6478b2ebc86e96388876f362bece93fe 100644
--- go-ethereum/cmd/rlpdump/rlpdump_test.go
+++ op-geth/cmd/rlpdump/rlpdump_test.go
@@ -22,8 +22,8 @@ "fmt"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
func TestRoundtrip(t *testing.T) {
diff --git go-ethereum/cmd/utils/export_test.go op-geth/cmd/utils/export_test.go
index 84ba8d0c316e63b0da21b5b5422b7bea5c6b19a4..5323cdc7945bccd2d1bfdb3847d85f2d35668842 100644
--- go-ethereum/cmd/utils/export_test.go
+++ op-geth/cmd/utils/export_test.go
@@ -23,8 +23,8 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/rlp"
)
// TestExport does basic sanity checks on the export/import functionality
diff --git go-ethereum/cmd/utils/history_test.go op-geth/cmd/utils/history_test.go
index 9b7f1797d8dd23c5eac5e1d493c914344c4bd3ac..f434fff2c0ea413847e107f09faa28d42ffc9620 100644
--- go-ethereum/cmd/utils/history_test.go
+++ op-geth/cmd/utils/history_test.go
@@ -26,17 +26,17 @@ "path"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/era"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/era"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/triedb"
)
var (
diff --git go-ethereum/common/bitutil/compress_test.go op-geth/common/bitutil/compress_test.go
index c6f6fe8bcf0241e698956b60eab2ca1c7dc1e23a..2cd7b07a3902d785a734835f93605a294753e528 100644
--- go-ethereum/common/bitutil/compress_test.go
+++ op-geth/common/bitutil/compress_test.go
@@ -22,7 +22,7 @@ "fmt"
"math/rand"
"testing"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common/hexutil"
)
// Tests that data bitset encoding and decoding works and is bijective.
diff --git go-ethereum/common/hexutil/json_example_test.go op-geth/common/hexutil/json_example_test.go
index 80180d918686458908bc3368ad1677299ba2569b..394a1edf60927602477bff7414af99f3c2e5e22c 100644
--- go-ethereum/common/hexutil/json_example_test.go
+++ op-geth/common/hexutil/json_example_test.go
@@ -20,7 +20,7 @@ import (
"encoding/json"
"fmt"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common/hexutil"
)
type MyType [5]byte
diff --git go-ethereum/common/math/big_test.go op-geth/common/math/big_test.go
index 803b5e1cc6174105df63d832b225ea52e87c4242..90e74c7d084b60765abfae0ae4bc84e2f700c705 100644
--- go-ethereum/common/math/big_test.go
+++ op-geth/common/math/big_test.go
@@ -22,7 +22,7 @@ "encoding/hex"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
func TestHexOrDecimal256(t *testing.T) {
diff --git go-ethereum/common/prque/lazyqueue_test.go op-geth/common/prque/lazyqueue_test.go
index ffb7e5e9e387e76934124dea4bced9a50598dc7c..c23e6bf065a2ecf454163d2c79d08f3d2f1b2054 100644
--- go-ethereum/common/prque/lazyqueue_test.go
+++ op-geth/common/prque/lazyqueue_test.go
@@ -22,7 +22,7 @@ "sync"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
+ "github.com/tenderly/op-geth/common/mclock"
)
const (
diff --git go-ethereum/consensus/clique/clique_test.go op-geth/consensus/clique/clique_test.go
index 8ef8dbffa974a1e5563a03894caafe1a4179f83e..478c1b7eb0f63ded15eadafb7ff1a034a55d7956 100644
--- go-ethereum/consensus/clique/clique_test.go
+++ op-geth/consensus/clique/clique_test.go
@@ -20,13 +20,13 @@ import (
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
)
// This test case is a repro of an annoying bug that took us forever to catch.
diff --git go-ethereum/consensus/clique/snapshot_test.go op-geth/consensus/clique/snapshot_test.go
index 26cebe008a88dbb2897ef067d455c534fa9f0a3a..5356a8c82b8a90a059ec59d45fddf304b9c737af 100644
--- go-ethereum/consensus/clique/snapshot_test.go
+++ op-geth/consensus/clique/snapshot_test.go
@@ -23,13 +23,13 @@ "fmt"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
"golang.org/x/exp/slices"
)
@@ -367,7 +367,7 @@ },
failure: errRecentlySigned,
}, {
// Recent signatures should not reset on checkpoint blocks imported in a new
- // batch (https://github.com/ethereum/go-ethereum/issues/17593). Whilst this
+ // batch (https://github.com/tenderly/op-geth/issues/17593). Whilst this
// seems overly specific and weird, it was a Rinkeby consensus split.
epoch: 3,
signers: []string{"A", "B", "C"},
diff --git go-ethereum/consensus/ethash/consensus_test.go op-geth/consensus/ethash/consensus_test.go
index e3793cd1b01ffce776a2ecf561cba62c49b5ad6b..b665a5e870af3f98fd663a3cfc2b92b1f12c865b 100644
--- go-ethereum/consensus/ethash/consensus_test.go
+++ op-geth/consensus/ethash/consensus_test.go
@@ -26,10 +26,10 @@ "os"
"path/filepath"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
type diffTest struct {
diff --git go-ethereum/consensus/misc/create2deployer_test.go op-geth/consensus/misc/create2deployer_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..03bee8eaa3ea3ad1fe815906d642853b1cf5a1d0
--- /dev/null
+++ op-geth/consensus/misc/create2deployer_test.go
@@ -0,0 +1,95 @@
+package misc
+
+import (
+ "math/big"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/params"
+)
+
+func TestEnsureCreate2Deployer(t *testing.T) {
+ canyonTime := uint64(1000)
+ var tests = []struct {
+ name string
+ override func(cfg *params.ChainConfig)
+ timestamp uint64
+ codeExists bool
+ applied bool
+ }{
+ {
+ name: "at hardfork",
+ timestamp: canyonTime,
+ applied: true,
+ },
+ {
+ name: "another chain ID",
+ override: func(cfg *params.ChainConfig) {
+ cfg.ChainID = big.NewInt(params.OPMainnetChainID)
+ },
+ timestamp: canyonTime,
+ applied: true,
+ },
+ {
+ name: "code already exists",
+ timestamp: canyonTime,
+ codeExists: true,
+ applied: true,
+ },
+ {
+ name: "pre canyon",
+ timestamp: canyonTime - 1,
+ applied: false,
+ },
+ {
+ name: "post hardfork",
+ timestamp: canyonTime + 1,
+ applied: false,
+ },
+ {
+ name: "canyon not configured",
+ override: func(cfg *params.ChainConfig) {
+ cfg.CanyonTime = nil
+ },
+ timestamp: canyonTime,
+ applied: false,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ cfg := params.ChainConfig{
+ ChainID: big.NewInt(params.BaseMainnetChainID),
+ Optimism: ¶ms.OptimismConfig{},
+ CanyonTime: &canyonTime,
+ }
+ if tt.override != nil {
+ tt.override(&cfg)
+ }
+ state := &stateDb{
+ codeExists: tt.codeExists,
+ }
+ EnsureCreate2Deployer(&cfg, tt.timestamp, state)
+ assert.Equal(t, tt.applied, state.codeSet)
+ })
+ }
+}
+
+type stateDb struct {
+ vm.StateDB
+ codeExists bool
+ codeSet bool
+}
+
+func (s *stateDb) GetCodeSize(_ common.Address) int {
+ if s.codeExists {
+ return 1
+ }
+ return 0
+}
+
+func (s *stateDb) SetCode(_ common.Address, _ []byte) {
+ s.codeSet = true
+}
diff --git go-ethereum/consensus/misc/eip1559/eip1559_test.go op-geth/consensus/misc/eip1559/eip1559_test.go
index b5afdf0fe5e56ca6ced6031be233c6aafb17dcdd..b6ffbd88ddeb01f35fc2d03920551a5475a3b8ef 100644
--- go-ethereum/consensus/misc/eip1559/eip1559_test.go
+++ op-geth/consensus/misc/eip1559/eip1559_test.go
@@ -20,9 +20,9 @@ import (
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
// copyConfig does a _shallow_ copy of a given config. Safe to set new values, but
@@ -52,6 +52,19 @@
func config() *params.ChainConfig {
config := copyConfig(params.TestChainConfig)
config.LondonBlock = big.NewInt(5)
+ return config
+}
+
+func opConfig() *params.ChainConfig {
+ config := copyConfig(params.TestChainConfig)
+ config.LondonBlock = big.NewInt(5)
+ ct := uint64(10)
+ config.CanyonTime = &ct
+ config.Optimism = ¶ms.OptimismConfig{
+ EIP1559Elasticity: 6,
+ EIP1559Denominator: 50,
+ EIP1559DenominatorCanyon: 250,
+ }
return config
}
@@ -124,7 +137,40 @@ GasLimit: test.parentGasLimit,
GasUsed: test.parentGasUsed,
BaseFee: big.NewInt(test.parentBaseFee),
}
- if have, want := CalcBaseFee(config(), parent), big.NewInt(test.expectedBaseFee); have.Cmp(want) != 0 {
+ if have, want := CalcBaseFee(config(), parent, 0), big.NewInt(test.expectedBaseFee); have.Cmp(want) != 0 {
+ t.Errorf("test %d: have %d want %d, ", i, have, want)
+ }
+ }
+}
+
+// TestCalcBaseFeeOptimism assumes all blocks are 1559-blocks but tests the Canyon activation
+func TestCalcBaseFeeOptimism(t *testing.T) {
+ tests := []struct {
+ parentBaseFee int64
+ parentGasLimit uint64
+ parentGasUsed uint64
+ expectedBaseFee int64
+ postCanyon bool
+ }{
+ {params.InitialBaseFee, 30_000_000, 5_000_000, params.InitialBaseFee, false}, // usage == target
+ {params.InitialBaseFee, 30_000_000, 4_000_000, 996000000, false}, // usage below target
+ {params.InitialBaseFee, 30_000_000, 10_000_000, 1020000000, false}, // usage above target
+ {params.InitialBaseFee, 30_000_000, 5_000_000, params.InitialBaseFee, true}, // usage == target
+ {params.InitialBaseFee, 30_000_000, 4_000_000, 999200000, true}, // usage below target
+ {params.InitialBaseFee, 30_000_000, 10_000_000, 1004000000, true}, // usage above target
+ }
+ for i, test := range tests {
+ parent := &types.Header{
+ Number: common.Big32,
+ GasLimit: test.parentGasLimit,
+ GasUsed: test.parentGasUsed,
+ BaseFee: big.NewInt(test.parentBaseFee),
+ Time: 6,
+ }
+ if test.postCanyon {
+ parent.Time = 8
+ }
+ if have, want := CalcBaseFee(opConfig(), parent, parent.Time+2), big.NewInt(test.expectedBaseFee); have.Cmp(want) != 0 {
t.Errorf("test %d: have %d want %d, ", i, have, want)
}
}
diff --git go-ethereum/consensus/misc/eip4844/eip4844_test.go op-geth/consensus/misc/eip4844/eip4844_test.go
index ec417380fcb083b54b3343aafa72767c9b8cbe06..344dea63ce2d8a9e1e7d8f1e18779b677891a6c9 100644
--- go-ethereum/consensus/misc/eip4844/eip4844_test.go
+++ op-geth/consensus/misc/eip4844/eip4844_test.go
@@ -21,7 +21,7 @@ "fmt"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/params"
)
func TestCalcExcessBlobGas(t *testing.T) {
diff --git go-ethereum/console/bridge_test.go op-geth/console/bridge_test.go
index e57e294fc5a5133176c4ce936c8a669492710a89..902e8476eed7570c1416fb7b2e67f63cb8b89d49 100644
--- go-ethereum/console/bridge_test.go
+++ op-geth/console/bridge_test.go
@@ -20,7 +20,7 @@ import (
"testing"
"github.com/dop251/goja"
- "github.com/ethereum/go-ethereum/internal/jsre"
+ "github.com/tenderly/op-geth/internal/jsre"
)
// TestUndefinedAsParam ensures that personal functions can receive
diff --git go-ethereum/console/console_test.go op-geth/console/console_test.go
index a13be6a99deda9516c3c807907a41e685b4e9e1f..bfde369da849793f9302e0a5049321deebc0c1c9 100644
--- go-ethereum/console/console_test.go
+++ op-geth/console/console_test.go
@@ -25,14 +25,14 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/console/prompt"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/internal/jsre"
- "github.com/ethereum/go-ethereum/miner"
- "github.com/ethereum/go-ethereum/node"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/console/prompt"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/internal/jsre"
+ "github.com/tenderly/op-geth/miner"
+ "github.com/tenderly/op-geth/node"
)
const (
diff --git go-ethereum/core/bench_test.go op-geth/core/bench_test.go
index 97713868a5473b49cc7b8d7a5fb5937d69e7d4b7..e57b1137a0b30aae136adddbc82691a81ec36ce8 100644
--- go-ethereum/core/bench_test.go
+++ op-geth/core/bench_test.go
@@ -21,15 +21,15 @@ "crypto/ecdsa"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/params"
)
func BenchmarkInsertChain_empty_memdb(b *testing.B) {
diff --git go-ethereum/core/block_validator_test.go op-geth/core/block_validator_test.go
index 385c0afd9d4086f354b2e305aa13f265efc321cf..9f2136ba8c80ca18fd7b93526ef7e30a941e0e40 100644
--- go-ethereum/core/block_validator_test.go
+++ op-geth/core/block_validator_test.go
@@ -21,16 +21,16 @@ "math/big"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/consensus/clique"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/consensus/clique"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
)
// Tests that simple header verification works, for both good and bad blocks.
diff --git go-ethereum/core/blockchain_repair_test.go op-geth/core/blockchain_repair_test.go
index b2df39d17bb8aa27da367c0329b9efe4a78183c0..8f9784f0a943cbf584ebabd5df87a95bac012960 100644
--- go-ethereum/core/blockchain_repair_test.go
+++ op-geth/core/blockchain_repair_test.go
@@ -26,12 +26,12 @@ "path"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/params"
)
// Tests a recovery for a short canonical chain where a recent block was already
@@ -1883,7 +1883,7 @@ t.Errorf("Frozen block count mismatch: have %d, want %d", frozen, tt.expFrozen)
}
}
-// TestIssue23496 tests scenario described in https://github.com/ethereum/go-ethereum/pull/23496#issuecomment-926393893
+// TestIssue23496 tests scenario described in https://github.com/tenderly/op-geth/pull/23496#issuecomment-926393893
// Credits to @zzyalbert for finding the issue.
//
// Local chain owns these blocks:
diff --git go-ethereum/core/blockchain_sethead_test.go op-geth/core/blockchain_sethead_test.go
index 1504c74e0ef354153cadb7d79b107f7d404c9521..37244b42b9fc53d064e38f511fae90502a67e6b7 100644
--- go-ethereum/core/blockchain_sethead_test.go
+++ op-geth/core/blockchain_sethead_test.go
@@ -27,16 +27,16 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/hashdb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/hashdb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
)
// rewindTest is a test case for chain rollback upon user request.
diff --git go-ethereum/core/blockchain_snapshot_test.go op-geth/core/blockchain_snapshot_test.go
index dd012c430c4d49a8cf247084423713de3a96b660..fd5a00cfee5049f42981f0490f8d54972b165f38 100644
--- go-ethereum/core/blockchain_snapshot_test.go
+++ op-geth/core/blockchain_snapshot_test.go
@@ -29,13 +29,13 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/params"
)
// snapshotTestBasic wraps the common testing fields in the snapshot tests.
diff --git go-ethereum/core/blockchain_test.go op-geth/core/blockchain_test.go
index 876d662f74d8ddc70c7e51711201ff476c5a0e50..864fae6d66ec25d18dec11c7654d0bee541e263c 100644
--- go-ethereum/core/blockchain_test.go
+++ op-geth/core/blockchain_test.go
@@ -26,21 +26,21 @@ "sync"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/tracers/logger"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/tracers/logger"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie"
)
// So we can deterministically seed different blockchains
@@ -1755,7 +1755,7 @@ // This is a regression test (i.e. as weird as it is, don't delete it ever), which
// tests that under weird reorg conditions the blockchain and its internal header-
// chain return the same latest block/header.
//
-// https://github.com/ethereum/go-ethereum/pull/15941
+// https://github.com/tenderly/op-geth/pull/15941
func TestBlockchainHeaderchainReorgConsistency(t *testing.T) {
testBlockchainHeaderchainReorgConsistency(t, rawdb.HashScheme)
testBlockchainHeaderchainReorgConsistency(t, rawdb.PathScheme)
@@ -2057,8 +2057,8 @@ // but where the difficulty per block is kept low: this means that it will not
// overtake the 'canon' chain until after it's passed canon by about 200 blocks.
//
// Details at:
-// - https://github.com/ethereum/go-ethereum/issues/18977
-// - https://github.com/ethereum/go-ethereum/pull/18988
+// - https://github.com/tenderly/op-geth/issues/18977
+// - https://github.com/tenderly/op-geth/pull/18988
func TestLowDiffLongChain(t *testing.T) {
testLowDiffLongChain(t, rawdb.HashScheme)
testLowDiffLongChain(t, rawdb.PathScheme)
diff --git go-ethereum/core/bloombits/generator_test.go op-geth/core/bloombits/generator_test.go
index ac1aee0b252472418c8dbd841228aa21b18ead6c..587cc08425e7598eea46bd3a906096c222cf4c1a 100644
--- go-ethereum/core/bloombits/generator_test.go
+++ op-geth/core/bloombits/generator_test.go
@@ -22,7 +22,7 @@ crand "crypto/rand"
"math/rand"
"testing"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/core/types"
)
// Tests that batched bloom bits are correctly rotated from the input bloom
diff --git go-ethereum/core/bloombits/matcher_test.go op-geth/core/bloombits/matcher_test.go
index 7f3d5f279ca389623e5bbd3933e92c11a1a4803e..7a570f24d3f3de2810a5ecbc4b383a2b9b5fff8c 100644
--- go-ethereum/core/bloombits/matcher_test.go
+++ op-geth/core/bloombits/matcher_test.go
@@ -23,7 +23,7 @@ "sync/atomic"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
const testSectionSize = 4096
@@ -86,7 +86,7 @@ }
// Tests that the matcher can properly find matches if the starting block is
// shifted from a multiple of 8. This is needed to cover an optimisation with
-// bitset matching https://github.com/ethereum/go-ethereum/issues/15309.
+// bitset matching https://github.com/tenderly/op-geth/issues/15309.
func TestMatcherShifted(t *testing.T) {
t.Parallel()
// Block 0 always matches in the tests, skip ahead of first 8 blocks with the
diff --git go-ethereum/core/chain_indexer_test.go op-geth/core/chain_indexer_test.go
index f099609015585c8f042af124b673ebdbf9219ad4..cd48ce404de0c03ff1752f71518612fd553416b3 100644
--- go-ethereum/core/chain_indexer_test.go
+++ op-geth/core/chain_indexer_test.go
@@ -25,9 +25,9 @@ "math/rand"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
)
// Runs multiple tests with randomized parameters.
diff --git go-ethereum/core/chain_makers_test.go op-geth/core/chain_makers_test.go
index b46b898afb92bd9a68c52029060b0eff5f976605..e9eeaf87e07cd343e1054a4544874c5ae5ebcdc5 100644
--- go-ethereum/core/chain_makers_test.go
+++ op-geth/core/chain_makers_test.go
@@ -23,15 +23,15 @@ "reflect"
"testing"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/triedb"
)
func TestGeneratePOSChain(t *testing.T) {
diff --git go-ethereum/core/dao_test.go op-geth/core/dao_test.go
index b9a899ef2f92f34ac69baff039b2d4bc3a50bf3c..a5b7e136a4227f3b5ae64d33387f734dabcbd6bb 100644
--- go-ethereum/core/dao_test.go
+++ op-geth/core/dao_test.go
@@ -20,10 +20,10 @@ import (
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/params"
)
// Tests that DAO-fork enabled clients can properly filter out fork-commencing
diff --git go-ethereum/core/forkid/forkid_test.go op-geth/core/forkid/forkid_test.go
index b9d346bd9051ae739181a0b8335da44dc585d8e6..24c1fe9325c29e0154fd1331e8aaf78764824d8d 100644
--- go-ethereum/core/forkid/forkid_test.go
+++ op-geth/core/forkid/forkid_test.go
@@ -23,11 +23,11 @@ "math"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
// TestCreation tests that different genesis and fork rule combinations result in
diff --git go-ethereum/core/genesis_test.go op-geth/core/genesis_test.go
index 61be0bd252c69d03d2d10914b3d73764fa5c149c..7ff6f54e85704a02a3ef7f966361cfc68c9885c0 100644
--- go-ethereum/core/genesis_test.go
+++ op-geth/core/genesis_test.go
@@ -24,15 +24,15 @@ "reflect"
"testing"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
)
func TestInvalidCliqueConfig(t *testing.T) {
diff --git go-ethereum/core/headerchain_test.go op-geth/core/headerchain_test.go
index 25d9bfffcb0bc2f3258fd70714d0e8b1e185023d..9af6e34150aaaf70aa95b89cf5ddc4c51cfd38f2 100644
--- go-ethereum/core/headerchain_test.go
+++ op-geth/core/headerchain_test.go
@@ -23,12 +23,12 @@ "math/big"
"testing"
"time"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/triedb"
)
func verifyUnbrokenCanonchain(hc *HeaderChain) error {
diff --git go-ethereum/core/rawdb/accessors_chain_test.go op-geth/core/rawdb/accessors_chain_test.go
index a7ceb72998a115653130a19932f443dfda3f7cc4..64b8d7a3bb30bfc561edc141d78523d3693a3ac2 100644
--- go-ethereum/core/rawdb/accessors_chain_test.go
+++ op-geth/core/rawdb/accessors_chain_test.go
@@ -26,11 +26,13 @@ "os"
"reflect"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/stretchr/testify/require"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/crypto/sha3"
)
@@ -347,6 +349,9 @@ // Create a live block since we need metadata to reconstruct the receipt
tx1 := types.NewTransaction(1, common.HexToAddress("0x1"), big.NewInt(1), 1, big.NewInt(1), nil)
tx2 := types.NewTransaction(2, common.HexToAddress("0x2"), big.NewInt(2), 2, big.NewInt(2), nil)
+ header := &types.Header{
+ Number: big.NewInt(0),
+ }
body := &types.Body{Transactions: types.Transactions{tx1, tx2}}
// Create the two receipts to manage afterwards
@@ -378,12 +383,15 @@ receipt2.Bloom = types.CreateBloom(types.Receipts{receipt2})
receipts := []*types.Receipt{receipt1, receipt2}
// Check that no receipt entries are in a pristine database
- hash := common.BytesToHash([]byte{0x03, 0x14})
+ hash := header.Hash()
if rs := ReadReceipts(db, hash, 0, 0, params.TestChainConfig); len(rs) != 0 {
t.Fatalf("non existent receipts returned: %v", rs)
}
// Insert the body that corresponds to the receipts
WriteBody(db, hash, 0, body)
+
+ // Insert the header that corresponds to the receipts
+ WriteHeader(db, header)
// Insert the receipt slice into the database and check presence
WriteReceipts(db, hash, 0, receipts)
@@ -694,36 +702,56 @@
// Create a live block since we need metadata to reconstruct the receipt
tx1 := types.NewTransaction(1, common.HexToAddress("0x1"), big.NewInt(1), 1, big.NewInt(1), nil)
tx2 := types.NewTransaction(2, common.HexToAddress("0x2"), big.NewInt(2), 2, big.NewInt(2), nil)
+ tx3 := types.NewTransaction(3, common.HexToAddress("0x3"), big.NewInt(3), 3, big.NewInt(3), nil)
- body := &types.Body{Transactions: types.Transactions{tx1, tx2}}
+ body := &types.Body{Transactions: types.Transactions{tx1, tx2, tx3}}
- // Create the two receipts to manage afterwards
- receipt1 := &types.Receipt{
+ // Create the three receipts to manage afterwards
+ depositNonce := uint64(math.MaxUint64)
+ depositReceipt := types.Receipt{
Status: types.ReceiptStatusFailed,
CumulativeGasUsed: 1,
Logs: []*types.Log{
{Address: common.BytesToAddress([]byte{0x11})},
{Address: common.BytesToAddress([]byte{0x01, 0x11})},
},
- TxHash: tx1.Hash(),
- ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
- GasUsed: 111111,
+ TxHash: tx1.Hash(),
+ ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
+ GasUsed: 111111,
+ DepositNonce: &depositNonce,
+ DepositReceiptVersion: nil,
}
- receipt1.Bloom = types.CreateBloom(types.Receipts{receipt1})
+ depositReceipt.Bloom = types.CreateBloom(types.Receipts{&depositReceipt})
- receipt2 := &types.Receipt{
- PostState: common.Hash{2}.Bytes(),
+ receiptVersion := types.CanyonDepositReceiptVersion
+ versionedDepositReceipt := types.Receipt{
+ Status: types.ReceiptStatusFailed,
CumulativeGasUsed: 2,
Logs: []*types.Log{
{Address: common.BytesToAddress([]byte{0x22})},
- {Address: common.BytesToAddress([]byte{0x02, 0x22})},
+ {Address: common.BytesToAddress([]byte{0x01, 0x11})},
+ },
+ TxHash: tx2.Hash(),
+ ContractAddress: common.BytesToAddress([]byte{0x02, 0x22, 0x22}),
+ GasUsed: 222222,
+ DepositNonce: &depositNonce,
+ DepositReceiptVersion: &receiptVersion,
+ }
+ versionedDepositReceipt.Bloom = types.CreateBloom(types.Receipts{&versionedDepositReceipt})
+
+ receipt := types.Receipt{
+ PostState: common.Hash{3}.Bytes(),
+ CumulativeGasUsed: 3,
+ Logs: []*types.Log{
+ {Address: common.BytesToAddress([]byte{0x33})},
+ {Address: common.BytesToAddress([]byte{0x03, 0x33})},
},
- TxHash: tx2.Hash(),
- ContractAddress: common.BytesToAddress([]byte{0x02, 0x22, 0x22}),
- GasUsed: 222222,
+ TxHash: tx3.Hash(),
+ ContractAddress: common.BytesToAddress([]byte{0x03, 0x33, 0x33}),
+ GasUsed: 333333,
}
- receipt2.Bloom = types.CreateBloom(types.Receipts{receipt2})
- receipts := []*types.Receipt{receipt1, receipt2}
+ receipt.Bloom = types.CreateBloom(types.Receipts{&receipt})
+ receipts := []*types.Receipt{&receipt, &depositReceipt, &versionedDepositReceipt}
hash := common.BytesToHash([]byte{0x03, 0x14})
// Check that no receipt entries are in a pristine database
@@ -740,14 +768,13 @@ logs := ReadLogs(db, hash, 0)
if len(logs) == 0 {
t.Fatalf("no logs returned")
}
- if have, want := len(logs), 2; have != want {
+ if have, want := len(logs), 3; have != want {
t.Fatalf("unexpected number of logs returned, have %d want %d", have, want)
}
- if have, want := len(logs[0]), 2; have != want {
- t.Fatalf("unexpected number of logs[0] returned, have %d want %d", have, want)
- }
- if have, want := len(logs[1]), 2; have != want {
- t.Fatalf("unexpected number of logs[1] returned, have %d want %d", have, want)
+ for i := range logs {
+ if have, want := len(logs[i]), 2; have != want {
+ t.Fatalf("unexpected number of logs[%d] returned, have %d want %d", i, have, want)
+ }
}
for i, pr := range receipts {
@@ -765,6 +792,36 @@ t.Fatalf("receipt #%d: receipt mismatch: have %s, want %s", i, hex.EncodeToString(rlpHave), hex.EncodeToString(rlpWant))
}
}
}
+}
+
+func TestParseLegacyReceiptRLP(t *testing.T) {
+ // Create a gasUsed value greater than a uint64 can represent
+ gasUsed := big.NewInt(0)
+ gasUsed = gasUsed.SetUint64(math.MaxUint64)
+ gasUsed = gasUsed.Add(gasUsed, big.NewInt(math.MaxInt64))
+ sanityCheck := (&big.Int{}).SetUint64(gasUsed.Uint64())
+ require.NotEqual(t, gasUsed, sanityCheck)
+ receipt := types.LegacyOptimismStoredReceiptRLP{
+ CumulativeGasUsed: 1,
+ Logs: []*types.LogForStorage{
+ {Address: common.BytesToAddress([]byte{0x11})},
+ {Address: common.BytesToAddress([]byte{0x01, 0x11})},
+ },
+ L1GasUsed: gasUsed,
+ L1GasPrice: gasUsed,
+ L1Fee: gasUsed,
+ FeeScalar: "6",
+ }
+
+ data, err := rlp.EncodeToBytes(receipt)
+ require.NoError(t, err)
+ var result storedReceiptRLP
+ err = rlp.DecodeBytes(data, &result)
+ require.NoError(t, err)
+ require.Equal(t, receipt.L1GasUsed, result.L1GasUsed)
+ require.Equal(t, receipt.L1GasPrice, result.L1GasPrice)
+ require.Equal(t, receipt.L1Fee, result.L1Fee)
+ require.Equal(t, receipt.FeeScalar, result.FeeScalar)
}
func TestDeriveLogFields(t *testing.T) {
diff --git go-ethereum/core/rawdb/accessors_indexes_test.go op-geth/core/rawdb/accessors_indexes_test.go
index 124389ba7a136c15c61ebb14e3498c669de64df5..d31f691bfa653473a7c2b5dffdb88f9d88d4c6f2 100644
--- go-ethereum/core/rawdb/accessors_indexes_test.go
+++ op-geth/core/rawdb/accessors_indexes_test.go
@@ -21,12 +21,12 @@ "bytes"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/internal/blocktest"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/internal/blocktest"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
var newTestHasher = blocktest.NewHasher
diff --git go-ethereum/core/rawdb/chain_iterator_test.go op-geth/core/rawdb/chain_iterator_test.go
index 78b0a82e10fecf49223a889a2e034c9f9b128519..b92ec3e62afa4d0523399b4f226af278d2fbabe4 100644
--- go-ethereum/core/rawdb/chain_iterator_test.go
+++ op-geth/core/rawdb/chain_iterator_test.go
@@ -23,8 +23,8 @@ "sort"
"sync"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
)
func TestChainIterator(t *testing.T) {
diff --git go-ethereum/core/rawdb/freezer_resettable_test.go op-geth/core/rawdb/freezer_resettable_test.go
index d741bc14e54fcb983db33aea8b7b5930f672a985..001875623834b8e0f252ec9c7c7f0505552257e1 100644
--- go-ethereum/core/rawdb/freezer_resettable_test.go
+++ op-geth/core/rawdb/freezer_resettable_test.go
@@ -21,7 +21,7 @@ "bytes"
"os"
"testing"
- "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/tenderly/op-geth/ethdb"
)
func TestResetFreezer(t *testing.T) {
diff --git go-ethereum/core/rawdb/freezer_table_test.go op-geth/core/rawdb/freezer_table_test.go
index 91b4943e5980e9870a9d031e29b0406d3e70dbec..c4fd6cd8e668cac222741f57656d0214dfb96c2a 100644
--- go-ethereum/core/rawdb/freezer_table_test.go
+++ op-geth/core/rawdb/freezer_table_test.go
@@ -28,8 +28,8 @@ "testing"
"testing/quick"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/metrics"
"github.com/stretchr/testify/require"
+ "github.com/tenderly/op-geth/metrics"
)
// TestFreezerBasics test initializing a freezertable from scratch, writing to the table,
diff --git go-ethereum/core/rawdb/freezer_test.go op-geth/core/rawdb/freezer_test.go
index b4bd6a382a867e20470a2aad43bb44129b03e229..72e92d0f3b8b4db2f7ae4da2e28e11c6044bca61 100644
--- go-ethereum/core/rawdb/freezer_test.go
+++ op-geth/core/rawdb/freezer_test.go
@@ -27,9 +27,9 @@ "path"
"sync"
"testing"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/stretchr/testify/require"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/rlp"
)
var freezerTestTableDef = map[string]bool{"test": true}
diff --git go-ethereum/core/rawdb/table_test.go op-geth/core/rawdb/table_test.go
index aa6adf3e72b1ed3feced05d39b4f31b6e9344b06..a21a9ef356749a719d44627524fcbb38190ff6f6 100644
--- go-ethereum/core/rawdb/table_test.go
+++ op-geth/core/rawdb/table_test.go
@@ -20,7 +20,7 @@ import (
"bytes"
"testing"
- "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/tenderly/op-geth/ethdb"
)
func TestTableDatabase(t *testing.T) { testTableDatabase(t, "prefix") }
diff --git go-ethereum/core/rlp_test.go op-geth/core/rlp_test.go
index bc37408537a3999a3c9d417e7f3106e9836ad149..d5cbd995098267306e10aacb13aff7f66c10ceab 100644
--- go-ethereum/core/rlp_test.go
+++ op-geth/core/rlp_test.go
@@ -21,12 +21,12 @@ "fmt"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/core/state/iterator_test.go op-geth/core/state/iterator_test.go
index 73cc22490b6ea7e976dbcb885a896f1692efbc59..03e601d59611e8cdffcde6e549ddc0badc33a1f1 100644
--- go-ethereum/core/state/iterator_test.go
+++ op-geth/core/state/iterator_test.go
@@ -19,9 +19,9 @@
import (
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/crypto"
)
// Tests that the node iterator indeed walks over the entire database contents.
diff --git go-ethereum/core/state/snapshot/difflayer_test.go op-geth/core/state/snapshot/difflayer_test.go
index 674a031b16089de0c1a4c5e2036409309bd76c59..2166a1ef6652db15a844340aad9625cc97ab2786 100644
--- go-ethereum/core/state/snapshot/difflayer_test.go
+++ op-geth/core/state/snapshot/difflayer_test.go
@@ -23,9 +23,9 @@ "math/rand"
"testing"
"github.com/VictoriaMetrics/fastcache"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb/memorydb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb/memorydb"
)
func copyDestructs(destructs map[common.Hash]struct{}) map[common.Hash]struct{} {
diff --git go-ethereum/core/state/snapshot/disklayer_test.go op-geth/core/state/snapshot/disklayer_test.go
index 168458c405192b91bda7aa658f206f0385fd1ed9..134af2bf1cf840ae41cfca9e6b379f61aa9b529a 100644
--- go-ethereum/core/state/snapshot/disklayer_test.go
+++ op-geth/core/state/snapshot/disklayer_test.go
@@ -21,10 +21,10 @@ "bytes"
"testing"
"github.com/VictoriaMetrics/fastcache"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb/memorydb"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb/memorydb"
+ "github.com/tenderly/op-geth/rlp"
)
// reverse reverses the contents of a byte slice. It's used to update random accs
diff --git go-ethereum/core/state/snapshot/generate_test.go op-geth/core/state/snapshot/generate_test.go
index da93ebc87506727a299a79d525414bc7b529a6bb..b4907b7df10588dda4f516f3a92b69cacb6bd697 100644
--- go-ethereum/core/state/snapshot/generate_test.go
+++ op-geth/core/state/snapshot/generate_test.go
@@ -22,18 +22,18 @@ "os"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/hashdb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/hashdb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/core/state/snapshot/holdable_iterator_test.go op-geth/core/state/snapshot/holdable_iterator_test.go
index ce4cf6bb8a63f5dbe1db765b13a4b7f22459b0c6..e9312b0fd9a44bf9918b9c71cf9b0ee50641ce09 100644
--- go-ethereum/core/state/snapshot/holdable_iterator_test.go
+++ op-geth/core/state/snapshot/holdable_iterator_test.go
@@ -20,8 +20,8 @@ import (
"bytes"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
)
func TestIteratorHold(t *testing.T) {
diff --git go-ethereum/core/state/snapshot/iterator_test.go op-geth/core/state/snapshot/iterator_test.go
index 54614427a5cf8e971e329c87ad62fee8f37c9a6a..fde84a0c571bb42ef7f8e15b08ade43df2da849c 100644
--- go-ethereum/core/state/snapshot/iterator_test.go
+++ op-geth/core/state/snapshot/iterator_test.go
@@ -25,8 +25,8 @@ "math/rand"
"testing"
"github.com/VictoriaMetrics/fastcache"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
)
// TestAccountIteratorBasics tests some simple single-layer(diff and disk) iteration
diff --git go-ethereum/core/state/snapshot/snapshot_test.go op-geth/core/state/snapshot/snapshot_test.go
index a9ab3eaea379ff7329e2aeec9388358d90db7626..3eca5cb8868b88f6a68c8668eedd99bb96ca7b1a 100644
--- go-ethereum/core/state/snapshot/snapshot_test.go
+++ op-geth/core/state/snapshot/snapshot_test.go
@@ -25,11 +25,11 @@ "testing"
"time"
"github.com/VictoriaMetrics/fastcache"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rlp"
)
// randomHash generates a random blob of data and returns it as a hash.
@@ -185,7 +185,7 @@ // be returned with junk data. This version of the test retains the bottom diff
// layer to check the usual mode of operation where the accumulator is retained.
func TestDiffLayerExternalInvalidationPartialFlatten(t *testing.T) {
// Un-commenting this triggers the bloom set to be deterministic. The values below
- // were used to trigger the flaw described in https://github.com/ethereum/go-ethereum/issues/27254.
+ // were used to trigger the flaw described in https://github.com/tenderly/op-geth/issues/27254.
// bloomDestructHasherOffset, bloomAccountHasherOffset, bloomStorageHasherOffset = 14, 24, 5
// Create an empty base layer and a snapshot tree out of it
diff --git go-ethereum/core/state/state_object_test.go op-geth/core/state/state_object_test.go
index 42fd7780258747412b3f9cfdf4ce3dedaffd6740..94fdcd7cd40897e1a60cf076519359e42316963f 100644
--- go-ethereum/core/state/state_object_test.go
+++ op-geth/core/state/state_object_test.go
@@ -20,7 +20,7 @@ import (
"bytes"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
func BenchmarkCutOriginal(b *testing.B) {
diff --git go-ethereum/core/state/state_test.go op-geth/core/state/state_test.go
index 9be610f962d56a02437d6f34ef0bb141e5eb905d..e9e5a3506ba9671c2f3d9d42ff12e8d6561f3db0 100644
--- go-ethereum/core/state/state_test.go
+++ op-geth/core/state/state_test.go
@@ -21,13 +21,13 @@ "bytes"
"encoding/json"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/triedb"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/triedb"
)
type stateEnv struct {
diff --git go-ethereum/core/state/statedb_fuzz_test.go op-geth/core/state/statedb_fuzz_test.go
index b416bcf1f3122dcfeaae80d02fe0a85389b0447c..56d3e2b37e6ba7d22954fc6db2d18d8dec407dcf 100644
--- go-ethereum/core/state/statedb_fuzz_test.go
+++ op-geth/core/state/statedb_fuzz_test.go
@@ -28,17 +28,17 @@ "strings"
"testing"
"testing/quick"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/trie/triestate"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state/snapshot"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/trie/triestate"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
)
// A stateTest checks that the state changes are correctly captured. Instances
diff --git go-ethereum/core/state/statedb_test.go op-geth/core/state/statedb_test.go
index cd86a7f4b67faa6f6bb393d9e7550be8e8effa6f..4791b27c9c3f09ab48f96491ce871db651d2a9f2 100644
--- go-ethereum/core/state/statedb_test.go
+++ op-geth/core/state/statedb_test.go
@@ -29,18 +29,18 @@ "sync"
"testing"
"testing/quick"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/hashdb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state/snapshot"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/hashdb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
)
// Tests that updating a state trie does not leak any database writes prior to
@@ -160,7 +160,7 @@ }
// TestCopy tests that copying a StateDB object indeed makes the original and
// the copy independent of each other. This test is a regression test against
-// https://github.com/ethereum/go-ethereum/pull/15549.
+// https://github.com/tenderly/op-geth/pull/15549.
func TestCopy(t *testing.T) {
// Create a random state test to copy and modify "independently"
orig, _ := New(types.EmptyRootHash, NewDatabase(rawdb.NewMemoryDatabase()), nil)
@@ -548,7 +548,7 @@ }
}
// TestCopyOfCopy tests that modified objects are carried over to the copy, and the copy of the copy.
-// See https://github.com/ethereum/go-ethereum/pull/15225#issuecomment-380191512
+// See https://github.com/tenderly/op-geth/pull/15225#issuecomment-380191512
func TestCopyOfCopy(t *testing.T) {
state, _ := New(types.EmptyRootHash, NewDatabase(rawdb.NewMemoryDatabase()), nil)
addr := common.HexToAddress("aaaa")
@@ -565,7 +565,7 @@
// Tests a regression where committing a copy lost some internal meta information,
// leading to corrupted subsequent copies.
//
-// See https://github.com/ethereum/go-ethereum/issues/20106.
+// See https://github.com/tenderly/op-geth/issues/20106.
func TestCopyCommitCopy(t *testing.T) {
tdb := NewDatabase(rawdb.NewMemoryDatabase())
state, _ := New(types.EmptyRootHash, tdb, nil)
@@ -639,7 +639,7 @@
// Tests a regression where committing a copy lost some internal meta information,
// leading to corrupted subsequent copies.
//
-// See https://github.com/ethereum/go-ethereum/issues/20106.
+// See https://github.com/tenderly/op-geth/issues/20106.
func TestCopyCopyCommitCopy(t *testing.T) {
state, _ := New(types.EmptyRootHash, NewDatabase(rawdb.NewMemoryDatabase()), nil)
diff --git go-ethereum/core/state/sync_test.go op-geth/core/state/sync_test.go
index 052c166578f78c49b411b0c40b029fe703f23efa..101e0bab5fdd39428c561b782473a50e5aa482c9 100644
--- go-ethereum/core/state/sync_test.go
+++ op-geth/core/state/sync_test.go
@@ -20,17 +20,17 @@ import (
"bytes"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/hashdb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/hashdb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
)
// testAccount is the data associated with an account used by the state tests.
diff --git go-ethereum/core/state/trie_prefetcher_test.go op-geth/core/state/trie_prefetcher_test.go
index 711ec832505a575ce503735d7fc612c0b196f63a..2ed1ed9fdf00e321d481155d283fb864e178f3af 100644
--- go-ethereum/core/state/trie_prefetcher_test.go
+++ op-geth/core/state/trie_prefetcher_test.go
@@ -21,10 +21,10 @@ "math/big"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
)
func filledStateDB() *StateDB {
diff --git go-ethereum/core/state_processor_test.go op-geth/core/state_processor_test.go
index 7718c0cde483dcc447ed867f60e469bec688208e..0dfe213c8542d870f0428664db74bc4cff8259f1 100644
--- go-ethereum/core/state_processor_test.go
+++ op-geth/core/state_processor_test.go
@@ -21,20 +21,20 @@ "crypto/ecdsa"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie"
"golang.org/x/crypto/sha3"
)
@@ -379,7 +379,7 @@ Time: parent.Time() + 10,
UncleHash: types.EmptyUncleHash,
}
if config.IsLondon(header.Number) {
- header.BaseFee = eip1559.CalcBaseFee(config, parent.Header())
+ header.BaseFee = eip1559.CalcBaseFee(config, parent.Header(), header.Time)
}
if config.IsShanghai(header.Number, header.Time) {
header.WithdrawalsHash = &types.EmptyWithdrawalsHash
diff --git go-ethereum/core/superchain_test.go op-geth/core/superchain_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..625f523e863fec920bc09d8bf79a4a7249dfa380
--- /dev/null
+++ op-geth/core/superchain_test.go
@@ -0,0 +1,53 @@
+package core
+
+import (
+ "testing"
+
+ "github.com/ethereum-optimism/superchain-registry/superchain"
+
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/triedb"
+)
+
+func TestOPStackGenesis(t *testing.T) {
+ for id := range superchain.OPChains {
+ _, err := LoadOPStackGenesis(id)
+ if err != nil {
+ t.Error(err)
+ }
+ }
+}
+
+func TestRegistryChainConfigOverride(t *testing.T) {
+ db := rawdb.NewMemoryDatabase()
+ genesis, err := LoadOPStackGenesis(10)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if genesis.Config.RegolithTime == nil {
+ t.Fatal("expected non-nil regolith time")
+ }
+ expectedRegolithTime := *genesis.Config.RegolithTime
+ genesis.Config.RegolithTime = nil
+
+ // initialize the DB
+ tdb := triedb.NewDatabase(db, newDbConfig(rawdb.PathScheme))
+ genesis.MustCommit(db, tdb)
+ bl := genesis.ToBlock()
+ rawdb.WriteCanonicalHash(db, bl.Hash(), 0)
+ rawdb.WriteBlock(db, bl)
+
+ // create chain config, even with incomplete genesis input: the chain config should be corrected
+ chainConfig, _, err := SetupGenesisBlockWithOverride(db, tdb, genesis, &ChainOverrides{
+ ApplySuperchainUpgrades: true,
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ // check if we have a corrected chain config
+ if chainConfig.RegolithTime == nil {
+ t.Fatal("expected regolith time to be corrected, but time is still nil")
+ } else if *chainConfig.RegolithTime != expectedRegolithTime {
+ t.Fatalf("expected regolith time to be %d, but got %d", expectedRegolithTime, *chainConfig.RegolithTime)
+ }
+}
diff --git go-ethereum/core/txindexer_test.go op-geth/core/txindexer_test.go
index 7b5ff1f206b2fa0546842f942154928d59f445dd..1ac3bb7e3eafc7bc26498ec7eff851d463238647 100644
--- go-ethereum/core/txindexer_test.go
+++ op-geth/core/txindexer_test.go
@@ -21,13 +21,13 @@ "math/big"
"os"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/params"
)
// TestTxIndexer tests the functionalities for managing transaction indexes.
diff --git go-ethereum/core/types/block_test.go op-geth/core/types/block_test.go
index cf0b1dd85c1e0e54bf3379067e67f235db699c1c..55d24ee7dfbd961975642f936d4d5ec8e055eb1e 100644
--- go-ethereum/core/types/block_test.go
+++ op-geth/core/types/block_test.go
@@ -22,12 +22,12 @@ "math/big"
"reflect"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/blocktest"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/blocktest"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
// from bcValidBlockTest.json, "SimpleTx"
diff --git go-ethereum/core/types/bloom9_test.go op-geth/core/types/bloom9_test.go
index d3178d112efb9570f0935a06536351128f4a4491..873ca877c1c1f47120ac81bf9154456830450087 100644
--- go-ethereum/core/types/bloom9_test.go
+++ op-geth/core/types/bloom9_test.go
@@ -21,8 +21,8 @@ "fmt"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
)
func TestBloom(t *testing.T) {
diff --git go-ethereum/core/types/hashing_test.go op-geth/core/types/hashing_test.go
index a6949414f300cd354cab09c8f392bcdebeb9a628..97c147763b3c8dde82e6724737963c144a59d92b 100644
--- go-ethereum/core/types/hashing_test.go
+++ op-geth/core/types/hashing_test.go
@@ -24,14 +24,14 @@ "math/big"
mrand "math/rand"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/triedb"
)
func TestDeriveSha(t *testing.T) {
diff --git go-ethereum/core/types/log_test.go op-geth/core/types/log_test.go
index 02eef3ecd43fc4a650823148ee1dbe1f0c113b3f..818c143e217c2ee671ac254fdedf24464a349cca 100644
--- go-ethereum/core/types/log_test.go
+++ op-geth/core/types/log_test.go
@@ -23,8 +23,8 @@ "reflect"
"testing"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var unmarshalLogTests = map[string]struct {
diff --git go-ethereum/core/types/receipt_test.go op-geth/core/types/receipt_test.go
index a7b26444712fe8c669ea732fa423588a58497f32..79ac20dddc6fc020a876d3968383c3f96cca8d16 100644
--- go-ethereum/core/types/receipt_test.go
+++ op-geth/core/types/receipt_test.go
@@ -19,19 +19,36 @@
import (
"bytes"
"encoding/json"
+ "fmt"
"math"
"math/big"
"reflect"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/holiman/uint256"
"github.com/kylelemons/godebug/diff"
+ "github.com/stretchr/testify/require"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
var (
+ bedrockGenesisTestConfig = func() *params.ChainConfig {
+ conf := *params.AllCliqueProtocolChanges // copy the config
+ conf.Clique = nil
+ conf.TerminalTotalDifficultyPassed = true
+ conf.BedrockBlock = big.NewInt(0)
+ conf.Optimism = ¶ms.OptimismConfig{EIP1559Elasticity: 50, EIP1559Denominator: 10}
+ return &conf
+ }()
+ ecotoneTestConfig = func() *params.ChainConfig {
+ conf := *bedrockGenesisTestConfig // copy the config
+ time := uint64(0)
+ conf.EcotoneTime = &time
+ return &conf
+ }()
+
legacyReceipt = &Receipt{
Status: ReceiptStatusFailed,
CumulativeGasUsed: 1,
@@ -82,6 +99,63 @@ },
},
Type: DynamicFeeTxType,
}
+ depositReceiptNoNonce = &Receipt{
+ Status: ReceiptStatusFailed,
+ CumulativeGasUsed: 1,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x01, 0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ },
+ Type: DepositTxType,
+ }
+ nonce = uint64(1234)
+ depositReceiptWithNonce = &Receipt{
+ Status: ReceiptStatusFailed,
+ CumulativeGasUsed: 1,
+ DepositNonce: &nonce,
+ DepositReceiptVersion: nil,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x01, 0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ },
+ Type: DepositTxType,
+ }
+ version = CanyonDepositReceiptVersion
+ depositReceiptWithNonceAndVersion = &Receipt{
+ Status: ReceiptStatusFailed,
+ CumulativeGasUsed: 1,
+ DepositNonce: &nonce,
+ DepositReceiptVersion: &version,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x01, 0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ },
+ Type: DepositTxType,
+ }
// Create a few transactions to have receipts for
to2 = common.HexToAddress("0x2")
@@ -149,11 +223,23 @@ GasFeeCap: uint256.NewInt(1077),
BlobFeeCap: uint256.NewInt(100077),
BlobHashes: []common.Hash{{}, {}, {}},
}),
+ NewTx(&DepositTx{
+ To: nil, // contract creation
+ Value: big.NewInt(6),
+ Gas: 50,
+ }),
+ NewTx(&DepositTx{
+ To: nil, // contract creation
+ Value: big.NewInt(6),
+ Gas: 60,
+ }),
}
-
- blockNumber = big.NewInt(1)
- blockTime = uint64(2)
- blockHash = common.BytesToHash([]byte{0x03, 0x14})
+ depNonce1 = uint64(7)
+ depNonce2 = uint64(8)
+ blockNumber = big.NewInt(1)
+ blockTime = uint64(2)
+ blockHash = common.BytesToHash([]byte{0x03, 0x14})
+ canyonDepositReceiptVersion = CanyonDepositReceiptVersion
// Create the corresponding receipts
receipts = Receipts{
@@ -293,6 +379,78 @@ BlockHash: blockHash,
BlockNumber: blockNumber,
TransactionIndex: 6,
},
+ &Receipt{
+ Type: DepositTxType,
+ PostState: common.Hash{5}.Bytes(),
+ CumulativeGasUsed: 50 + 28,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x33}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[7].Hash(),
+ TxIndex: 7,
+ BlockHash: blockHash,
+ Index: 4,
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x03, 0x33}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[7].Hash(),
+ TxIndex: 7,
+ BlockHash: blockHash,
+ Index: 5,
+ },
+ },
+ TxHash: txs[7].Hash(),
+ ContractAddress: common.HexToAddress("0x3bb898b4bbe24f68a4e9be46cfe72d1787fd74f4"),
+ GasUsed: 50,
+ EffectiveGasPrice: big.NewInt(0),
+ BlockHash: blockHash,
+ BlockNumber: blockNumber,
+ TransactionIndex: 7,
+ DepositNonce: &depNonce1,
+ DepositReceiptVersion: nil,
+ },
+ &Receipt{
+ Type: DepositTxType,
+ PostState: common.Hash{5}.Bytes(),
+ CumulativeGasUsed: 60 + 50 + 28,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x33}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[8].Hash(),
+ TxIndex: 8,
+ BlockHash: blockHash,
+ Index: 6,
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x03, 0x33}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[8].Hash(),
+ TxIndex: 8,
+ BlockHash: blockHash,
+ Index: 7,
+ },
+ },
+ TxHash: txs[8].Hash(),
+ ContractAddress: common.HexToAddress("0x117814af22cb83d8ad6e8489e9477d28265bc105"),
+ GasUsed: 60,
+ EffectiveGasPrice: big.NewInt(0),
+ BlockHash: blockHash,
+ BlockNumber: blockNumber,
+ TransactionIndex: 8,
+ DepositNonce: &depNonce2,
+ DepositReceiptVersion: &canyonDepositReceiptVersion,
+ },
}
)
@@ -308,10 +466,10 @@
// Tests that receipt data can be correctly derived from the contextual infos
func TestDeriveFields(t *testing.T) {
// Re-derive receipts.
- basefee := big.NewInt(1000)
+ baseFee := big.NewInt(1000)
blobGasPrice := big.NewInt(920)
derivedReceipts := clearComputedFieldsOnReceipts(receipts)
- err := Receipts(derivedReceipts).DeriveFields(params.TestChainConfig, blockHash, blockNumber.Uint64(), blockTime, basefee, blobGasPrice, txs)
+ err := Receipts(derivedReceipts).DeriveFields(params.TestChainConfig, blockHash, blockNumber.Uint64(), blockTime, baseFee, blobGasPrice, txs)
if err != nil {
t.Fatalf("DeriveFields(...) = %v, want <nil>", err)
}
@@ -344,6 +502,18 @@ r := Receipt{}
err = r.UnmarshalJSON(b)
if err != nil {
t.Fatal("error unmarshaling receipt from json:", err)
+ }
+
+ // Make sure marshal/unmarshal doesn't affect receipt hash root computation by comparing
+ // the output of EncodeIndex
+ rsBefore := Receipts([]*Receipt{receipts[i]})
+ rsAfter := Receipts([]*Receipt{&r})
+
+ encBefore, encAfter := bytes.Buffer{}, bytes.Buffer{}
+ rsBefore.EncodeIndex(0, &encBefore)
+ rsAfter.EncodeIndex(0, &encAfter)
+ if !bytes.Equal(encBefore.Bytes(), encAfter.Bytes()) {
+ t.Errorf("%v: EncodeIndex differs after JSON marshal/unmarshal", i)
}
}
}
@@ -527,3 +697,365 @@ l[i] = &cpy
}
return l
}
+
+func getOptimismEcotoneTxReceipts(l1AttributesPayload []byte, l1GasPrice, l1BlobGasPrice, l1GasUsed, l1Fee *big.Int, baseFeeScalar, blobBaseFeeScalar *uint64) ([]*Transaction, []*Receipt) {
+ // Create a few transactions to have receipts for
+ txs := Transactions{
+ NewTx(&DepositTx{
+ To: nil, // contract creation
+ Value: big.NewInt(6),
+ Gas: 50,
+ Data: l1AttributesPayload,
+ }),
+ emptyTx,
+ }
+
+ // Create the corresponding receipts
+ receipts := Receipts{
+ &Receipt{
+ Type: DepositTxType,
+ PostState: common.Hash{5}.Bytes(),
+ CumulativeGasUsed: 50 + 15,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x33}),
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[0].Hash(),
+ TxIndex: 0,
+ BlockHash: blockHash,
+ Index: 0,
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x03, 0x33}),
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[0].Hash(),
+ TxIndex: 0,
+ BlockHash: blockHash,
+ Index: 1,
+ },
+ },
+ TxHash: txs[0].Hash(),
+ ContractAddress: common.HexToAddress("0x3bb898b4bbe24f68a4e9be46cfe72d1787fd74f4"),
+ GasUsed: 65,
+ EffectiveGasPrice: big.NewInt(0),
+ BlockHash: blockHash,
+ BlockNumber: blockNumber,
+ TransactionIndex: 0,
+ DepositNonce: &depNonce1,
+ },
+ &Receipt{
+ Type: LegacyTxType,
+ EffectiveGasPrice: big.NewInt(0),
+ PostState: common.Hash{4}.Bytes(),
+ CumulativeGasUsed: 10,
+ Logs: []*Log{},
+ // derived fields:
+ TxHash: txs[1].Hash(),
+ GasUsed: 18446744073709551561,
+ BlockHash: blockHash,
+ BlockNumber: blockNumber,
+ TransactionIndex: 1,
+ L1GasPrice: l1GasPrice,
+ L1BlobBaseFee: l1BlobGasPrice,
+ L1GasUsed: l1GasUsed,
+ L1Fee: l1Fee,
+ L1BaseFeeScalar: baseFeeScalar,
+ L1BlobBaseFeeScalar: blobBaseFeeScalar,
+ },
+ }
+ return txs, receipts
+}
+
+func getOptimismTxReceipts(l1AttributesPayload []byte, l1GasPrice, l1GasUsed, l1Fee *big.Int, feeScalar *big.Float) ([]*Transaction, []*Receipt) {
+ // Create a few transactions to have receipts for
+ txs := Transactions{
+ NewTx(&DepositTx{
+ To: nil, // contract creation
+ Value: big.NewInt(6),
+ Gas: 50,
+ Data: l1AttributesPayload,
+ }),
+ emptyTx,
+ }
+
+ // Create the corresponding receipts
+ receipts := Receipts{
+ &Receipt{
+ Type: DepositTxType,
+ PostState: common.Hash{5}.Bytes(),
+ CumulativeGasUsed: 50 + 15,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x33}),
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[0].Hash(),
+ TxIndex: 0,
+ BlockHash: blockHash,
+ Index: 0,
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x03, 0x33}),
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[0].Hash(),
+ TxIndex: 0,
+ BlockHash: blockHash,
+ Index: 1,
+ },
+ },
+ TxHash: txs[0].Hash(),
+ ContractAddress: common.HexToAddress("0x3bb898b4bbe24f68a4e9be46cfe72d1787fd74f4"),
+ GasUsed: 65,
+ EffectiveGasPrice: big.NewInt(0),
+ BlockHash: blockHash,
+ BlockNumber: blockNumber,
+ TransactionIndex: 0,
+ DepositNonce: &depNonce1,
+ },
+ &Receipt{
+ Type: LegacyTxType,
+ EffectiveGasPrice: big.NewInt(0),
+ PostState: common.Hash{4}.Bytes(),
+ CumulativeGasUsed: 10,
+ Logs: []*Log{},
+ // derived fields:
+ TxHash: txs[1].Hash(),
+ GasUsed: 18446744073709551561,
+ BlockHash: blockHash,
+ BlockNumber: blockNumber,
+ TransactionIndex: 1,
+ L1GasPrice: l1GasPrice,
+ L1GasUsed: l1GasUsed,
+ L1Fee: l1Fee,
+ FeeScalar: feeScalar,
+ },
+ }
+ return txs, receipts
+}
+
+func TestDeriveOptimismBedrockTxReceipts(t *testing.T) {
+ // Bedrock style l1 attributes with L1Scalar=7_000_000 (becomes 7 after division), L1Overhead=50, L1BaseFee=1000*1e6
+ payload := common.Hex2Bytes("015d8eb900000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d2000000000000000000000000000000000000000000000000000000003b9aca0000000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d2000000000000000000000000000000000000000000000000000000000000003200000000000000000000000000000000000000000000000000000000006acfc0015d8eb900000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d2000000000000000000000000000000000000000000000000000000003b9aca0000000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d2000000000000000000000000000000000000000000000000000000000000003200000000000000000000000000000000000000000000000000000000006acfc0")
+ // the parameters we use below are defined in rollup_test.go
+ l1GasPrice := baseFee
+ l1GasUsed := bedrockGas
+ feeScalar := big.NewFloat(float64(scalar.Uint64() / 1e6))
+ l1Fee := bedrockFee
+ txs, receipts := getOptimismTxReceipts(payload, l1GasPrice, l1GasUsed, l1Fee, feeScalar)
+
+ // Re-derive receipts.
+ baseFee := big.NewInt(1000)
+ derivedReceipts := clearComputedFieldsOnReceipts(receipts)
+ err := Receipts(derivedReceipts).DeriveFields(bedrockGenesisTestConfig, blockHash, blockNumber.Uint64(), 0, baseFee, nil, txs)
+ if err != nil {
+ t.Fatalf("DeriveFields(...) = %v, want <nil>", err)
+ }
+ checkBedrockReceipts(t, receipts, derivedReceipts)
+
+ // Should get same result with the Ecotone config because it will assume this is "first ecotone block"
+ // if it sees the bedrock style L1 attributes.
+ err = Receipts(derivedReceipts).DeriveFields(ecotoneTestConfig, blockHash, blockNumber.Uint64(), 0, baseFee, nil, txs)
+ if err != nil {
+ t.Fatalf("DeriveFields(...) = %v, want <nil>", err)
+ }
+ checkBedrockReceipts(t, receipts, derivedReceipts)
+}
+
+func TestDeriveOptimismEcotoneTxReceipts(t *testing.T) {
+ // Ecotone style l1 attributes with baseFeeScalar=2, blobBaseFeeScalar=3, baseFee=1000*1e6, blobBaseFee=10*1e6
+ payload := common.Hex2Bytes("440a5e20000000020000000300000000000004d200000000000004d200000000000004d2000000000000000000000000000000000000000000000000000000003b9aca00000000000000000000000000000000000000000000000000000000000098968000000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d2")
+ // the parameters we use below are defined in rollup_test.go
+ baseFeeScalarUint64 := baseFeeScalar.Uint64()
+ blobBaseFeeScalarUint64 := blobBaseFeeScalar.Uint64()
+ txs, receipts := getOptimismEcotoneTxReceipts(payload, baseFee, blobBaseFee, ecotoneGas, ecotoneFee, &baseFeeScalarUint64, &blobBaseFeeScalarUint64)
+
+ // Re-derive receipts.
+ baseFee := big.NewInt(1000)
+ derivedReceipts := clearComputedFieldsOnReceipts(receipts)
+ // Should error out if we try to process this with a pre-Ecotone config
+ err := Receipts(derivedReceipts).DeriveFields(bedrockGenesisTestConfig, blockHash, blockNumber.Uint64(), 0, baseFee, nil, txs)
+ if err == nil {
+ t.Fatalf("expected error from deriving ecotone receipts with pre-ecotone config, got none")
+ }
+
+ err = Receipts(derivedReceipts).DeriveFields(ecotoneTestConfig, blockHash, blockNumber.Uint64(), 0, baseFee, nil, txs)
+ if err != nil {
+ t.Fatalf("DeriveFields(...) = %v, want <nil>", err)
+ }
+ diffReceipts(t, receipts, derivedReceipts)
+}
+
+func diffReceipts(t *testing.T, receipts, derivedReceipts []*Receipt) {
+ // Check diff of receipts against derivedReceipts.
+ r1, err := json.MarshalIndent(receipts, "", " ")
+ if err != nil {
+ t.Fatal("error marshaling input receipts:", err)
+ }
+ r2, err := json.MarshalIndent(derivedReceipts, "", " ")
+ if err != nil {
+ t.Fatal("error marshaling derived receipts:", err)
+ }
+ d := diff.Diff(string(r1), string(r2))
+ if d != "" {
+ t.Fatal("receipts differ:", d)
+ }
+}
+
+func checkBedrockReceipts(t *testing.T, receipts, derivedReceipts []*Receipt) {
+ diffReceipts(t, receipts, derivedReceipts)
+
+ // Check that we preserved the invariant: l1Fee = l1GasPrice * l1GasUsed * l1FeeScalar
+ // but with more difficult int math...
+ l2Rcpt := derivedReceipts[1]
+ l1GasCost := new(big.Int).Mul(l2Rcpt.L1GasPrice, l2Rcpt.L1GasUsed)
+ l1Fee := new(big.Float).Mul(new(big.Float).SetInt(l1GasCost), l2Rcpt.FeeScalar)
+ require.Equal(t, new(big.Float).SetInt(l2Rcpt.L1Fee), l1Fee)
+}
+
+func TestBedrockDepositReceiptUnchanged(t *testing.T) {
+ expectedRlp := common.FromHex("7EF90156A003000000000000000000000000000000000000000000000000000000000000000AB9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F0D7940000000000000000000000000000000000000033C001D7940000000000000000000000000000000000000333C002")
+ // Deposit receipt with no nonce
+ receipt := &Receipt{
+ Type: DepositTxType,
+ PostState: common.Hash{3}.Bytes(),
+ CumulativeGasUsed: 10,
+ Logs: []*Log{
+ {Address: common.BytesToAddress([]byte{0x33}), Data: []byte{1}, Topics: []common.Hash{}},
+ {Address: common.BytesToAddress([]byte{0x03, 0x33}), Data: []byte{2}, Topics: []common.Hash{}},
+ },
+ TxHash: common.Hash{},
+ ContractAddress: common.BytesToAddress([]byte{0x03, 0x33, 0x33}),
+ GasUsed: 4,
+ }
+
+ rlp, err := receipt.MarshalBinary()
+ require.NoError(t, err)
+ require.Equal(t, expectedRlp, rlp)
+
+ // Consensus values should be unchanged after reparsing
+ parsed := new(Receipt)
+ err = parsed.UnmarshalBinary(rlp)
+ require.NoError(t, err)
+ require.Equal(t, receipt.Status, parsed.Status)
+ require.Equal(t, receipt.CumulativeGasUsed, parsed.CumulativeGasUsed)
+ require.Equal(t, receipt.Bloom, parsed.Bloom)
+ require.EqualValues(t, receipt.Logs, parsed.Logs)
+ // And still shouldn't have a nonce
+ require.Nil(t, parsed.DepositNonce)
+ // ..or a deposit nonce
+ require.Nil(t, parsed.DepositReceiptVersion)
+}
+
+// Regolith introduced an inconsistency in behavior between EncodeIndex and MarshalBinary for a
+// deposit transaction receipt. TestReceiptEncodeIndexBugIsEnshrined makes sure this difference is
+// preserved for backwards compatibility purposes, but also that there is no discrepancy for the
+// post-Canyon encoding.
+func TestReceiptEncodeIndexBugIsEnshrined(t *testing.T) {
+ // Check that a post-Regolith, pre-Canyon receipt produces the expected difference between
+ // EncodeIndex and MarshalBinary.
+ buf := new(bytes.Buffer)
+ receipts := Receipts{depositReceiptWithNonce}
+ receipts.EncodeIndex(0, buf)
+ indexBytes := buf.Bytes()
+
+ regularBytes, _ := receipts[0].MarshalBinary()
+
+ require.NotEqual(t, indexBytes, regularBytes)
+
+ // Confirm the buggy encoding is as expected, which means it should encode as if it had no
+ // nonce specified (like that of a non-deposit receipt, whose encoding would differ only in the
+ // type byte).
+ buf.Reset()
+ tempReceipt := *depositReceiptWithNonce
+ tempReceipt.Type = eip1559Receipt.Type
+ buggyBytes, _ := tempReceipt.MarshalBinary()
+
+ require.Equal(t, indexBytes[1:], buggyBytes[1:])
+
+ // check that the post-Canyon encoding has no differences between EncodeIndex and
+ // MarshalBinary.
+ buf.Reset()
+ receipts = Receipts{depositReceiptWithNonceAndVersion}
+ receipts.EncodeIndex(0, buf)
+ indexBytes = buf.Bytes()
+
+ regularBytes, _ = receipts[0].MarshalBinary()
+
+ require.Equal(t, indexBytes, regularBytes)
+
+ // Check that bumping the nonce post-canyon changes the hash
+ bumpedReceipt := *depositReceiptWithNonceAndVersion
+ bumpedNonce := nonce + 1
+ bumpedReceipt.DepositNonce = &bumpedNonce
+ bumpedBytes, _ := bumpedReceipt.MarshalBinary()
+ require.NotEqual(t, regularBytes, bumpedBytes)
+}
+
+func TestRoundTripReceipt(t *testing.T) {
+ tests := []struct {
+ name string
+ rcpt *Receipt
+ }{
+ {name: "Legacy", rcpt: legacyReceipt},
+ {name: "AccessList", rcpt: accessListReceipt},
+ {name: "EIP1559", rcpt: eip1559Receipt},
+ {name: "DepositNoNonce", rcpt: depositReceiptNoNonce},
+ {name: "DepositWithNonce", rcpt: depositReceiptWithNonce},
+ {name: "DepositWithNonceAndVersion", rcpt: depositReceiptWithNonceAndVersion},
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ data, err := test.rcpt.MarshalBinary()
+ require.NoError(t, err)
+
+ d := &Receipt{}
+ err = d.UnmarshalBinary(data)
+ require.NoError(t, err)
+ require.Equal(t, test.rcpt, d)
+ require.Equal(t, test.rcpt.DepositNonce, d.DepositNonce)
+ require.Equal(t, test.rcpt.DepositReceiptVersion, d.DepositReceiptVersion)
+ })
+
+ t.Run(fmt.Sprintf("%sRejectExtraData", test.name), func(t *testing.T) {
+ data, err := test.rcpt.MarshalBinary()
+ require.NoError(t, err)
+ data = append(data, 1, 2, 3, 4)
+ d := &Receipt{}
+ err = d.UnmarshalBinary(data)
+ require.Error(t, err)
+ })
+ }
+}
+
+func TestRoundTripReceiptForStorage(t *testing.T) {
+ tests := []struct {
+ name string
+ rcpt *Receipt
+ }{
+ {name: "Legacy", rcpt: legacyReceipt},
+ {name: "AccessList", rcpt: accessListReceipt},
+ {name: "EIP1559", rcpt: eip1559Receipt},
+ {name: "DepositNoNonce", rcpt: depositReceiptNoNonce},
+ {name: "DepositWithNonce", rcpt: depositReceiptWithNonce},
+ {name: "DepositWithNonceAndVersion", rcpt: depositReceiptWithNonceAndVersion},
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ data, err := rlp.EncodeToBytes((*ReceiptForStorage)(test.rcpt))
+ require.NoError(t, err)
+
+ d := &ReceiptForStorage{}
+ err = rlp.DecodeBytes(data, d)
+ require.NoError(t, err)
+ // Only check the stored fields - the others are derived later
+ require.Equal(t, test.rcpt.Status, d.Status)
+ require.Equal(t, test.rcpt.CumulativeGasUsed, d.CumulativeGasUsed)
+ require.Equal(t, test.rcpt.Logs, d.Logs)
+ require.Equal(t, test.rcpt.DepositNonce, d.DepositNonce)
+ require.Equal(t, test.rcpt.DepositReceiptVersion, d.DepositReceiptVersion)
+ })
+ }
+}
diff --git go-ethereum/core/types/rlp_fuzzer_test.go op-geth/core/types/rlp_fuzzer_test.go
index a3b9f72436b96e127e00c957b99639ca55a57e9f..32849e24164a78696ee722846b68cde1ba744348 100644
--- go-ethereum/core/types/rlp_fuzzer_test.go
+++ op-geth/core/types/rlp_fuzzer_test.go
@@ -22,8 +22,8 @@ "fmt"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/rlp"
)
func decodeEncode(input []byte, val interface{}) error {
diff --git go-ethereum/core/types/rollup_cost_test.go op-geth/core/types/rollup_cost_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..dbfd4bfd2fb5a82f65ab3f159d7bf5d7538fcdc8
--- /dev/null
+++ op-geth/core/types/rollup_cost_test.go
@@ -0,0 +1,407 @@
+package types
+
+import (
+ "bytes"
+ "encoding/binary"
+ "encoding/hex"
+ "math/big"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/params"
+)
+
+var (
+ baseFee = big.NewInt(1000 * 1e6)
+ overhead = big.NewInt(50)
+ scalar = big.NewInt(7 * 1e6)
+
+ blobBaseFee = big.NewInt(10 * 1e6)
+ baseFeeScalar = big.NewInt(2)
+ blobBaseFeeScalar = big.NewInt(3)
+
+ // below are the expected cost func outcomes for the above parameter settings on the emptyTx
+ // which is defined in transaction_test.go
+ bedrockFee = big.NewInt(11326000000000)
+ regolithFee = big.NewInt(3710000000000)
+ ecotoneFee = big.NewInt(960900) // (480/16)*(2*16*1000 + 3*10) == 960900
+ // the emptyTx is out of bounds for the linear regression so it uses the minimum size
+ fjordFee = big.NewInt(3203000) // 100_000_000 * (2 * 1000 * 1e6 * 16 + 3 * 10 * 1e6) / 1e12
+
+ bedrockGas = big.NewInt(1618)
+ regolithGas = big.NewInt(530) // 530 = 1618 - (16*68)
+ ecotoneGas = big.NewInt(480)
+ minimumFjordGas = big.NewInt(1600) // fastlz size of minimum txn, 100_000_000 * 16 / 1e6
+)
+
+func TestBedrockL1CostFunc(t *testing.T) {
+ costFunc0 := newL1CostFuncBedrockHelper(baseFee, overhead, scalar, false /*isRegolith*/)
+ costFunc1 := newL1CostFuncBedrockHelper(baseFee, overhead, scalar, true)
+
+ c0, g0 := costFunc0(emptyTx.RollupCostData()) // pre-Regolith
+ c1, g1 := costFunc1(emptyTx.RollupCostData())
+
+ require.Equal(t, bedrockFee, c0)
+ require.Equal(t, bedrockGas, g0) // gas-used
+
+ require.Equal(t, regolithFee, c1)
+ require.Equal(t, regolithGas, g1)
+}
+
+func TestEcotoneL1CostFunc(t *testing.T) {
+ costFunc := newL1CostFuncEcotone(baseFee, blobBaseFee, baseFeeScalar, blobBaseFeeScalar)
+
+ c0, g0 := costFunc(emptyTx.RollupCostData())
+
+ require.Equal(t, ecotoneGas, g0)
+ require.Equal(t, ecotoneFee, c0)
+}
+
+func TestFjordL1CostFuncMinimumBounds(t *testing.T) {
+ costFunc := NewL1CostFuncFjord(
+ baseFee,
+ blobBaseFee,
+ baseFeeScalar,
+ blobBaseFeeScalar,
+ )
+
+ // Minimum size transactions:
+ // -42.5856 + 0.8365*110 = 49.4294
+ // -42.5856 + 0.8365*150 = 82.8894
+ // -42.5856 + 0.8365*170 = 99.6194
+ for _, fastLzsize := range []uint64{100, 150, 170} {
+ c, g := costFunc(RollupCostData{
+ FastLzSize: fastLzsize,
+ })
+
+ require.Equal(t, minimumFjordGas, g)
+ require.Equal(t, fjordFee, c)
+ }
+
+ // Larger size transactions:
+ // -42.5856 + 0.8365*171 = 100.4559
+ // -42.5856 + 0.8365*175 = 108.8019
+ // -42.5856 + 0.8365*200 = 124.7144
+ for _, fastLzsize := range []uint64{171, 175, 200} {
+ c, g := costFunc(RollupCostData{
+ FastLzSize: fastLzsize,
+ })
+
+ require.Greater(t, g.Uint64(), minimumFjordGas.Uint64())
+ require.Greater(t, c.Uint64(), fjordFee.Uint64())
+ }
+}
+
+// TestFjordL1CostSolidityParity tests that the cost function for the fjord upgrade matches a Solidity
+// test to ensure the outputs are the same.
+func TestFjordL1CostSolidityParity(t *testing.T) {
+ costFunc := NewL1CostFuncFjord(
+ big.NewInt(2*1e6),
+ big.NewInt(3*1e6),
+ big.NewInt(20),
+ big.NewInt(15),
+ )
+
+ c0, g0 := costFunc(RollupCostData{
+ FastLzSize: 235,
+ })
+
+ require.Equal(t, big.NewInt(2463), g0)
+ require.Equal(t, big.NewInt(105484), c0)
+}
+
+func TestExtractBedrockGasParams(t *testing.T) {
+ regolithTime := uint64(1)
+ config := ¶ms.ChainConfig{
+ Optimism: params.OptimismTestConfig.Optimism,
+ RegolithTime: ®olithTime,
+ }
+
+ data := getBedrockL1Attributes(baseFee, overhead, scalar)
+
+ gasparams, err := extractL1GasParams(config, regolithTime-1, data)
+ costFuncPreRegolith := gasparams.costFunc
+ require.NoError(t, err)
+
+ // Function should continue to succeed even with extra data (that just gets ignored) since we
+ // have been testing the data size is at least the expected number of bytes instead of exactly
+ // the expected number of bytes. It's unclear if this flexibility was intentional, but since
+ // it's been in production we shouldn't change this behavior.
+ data = append(data, []byte{0xBE, 0xEE, 0xEE, 0xFF}...) // tack on garbage data
+ gasparams, err = extractL1GasParams(config, regolithTime, data)
+ costFuncRegolith := gasparams.costFunc
+ require.NoError(t, err)
+
+ c, _ := costFuncPreRegolith(emptyTx.RollupCostData())
+ require.Equal(t, bedrockFee, c)
+
+ c, _ = costFuncRegolith(emptyTx.RollupCostData())
+ require.Equal(t, regolithFee, c)
+
+ // try to extract from data which has not enough params, should get error.
+ data = data[:len(data)-4-32]
+ _, err = extractL1GasParams(config, regolithTime, data)
+ require.Error(t, err)
+}
+
+func TestExtractEcotoneGasParams(t *testing.T) {
+ zeroTime := uint64(0)
+ // create a config where ecotone upgrade is active
+ config := ¶ms.ChainConfig{
+ Optimism: params.OptimismTestConfig.Optimism,
+ RegolithTime: &zeroTime,
+ EcotoneTime: &zeroTime,
+ }
+ require.True(t, config.IsOptimismEcotone(zeroTime))
+
+ data := getEcotoneL1Attributes(
+ baseFee,
+ blobBaseFee,
+ baseFeeScalar,
+ blobBaseFeeScalar,
+ )
+
+ gasparams, err := extractL1GasParams(config, zeroTime, data)
+ require.NoError(t, err)
+ costFunc := gasparams.costFunc
+
+ c, g := costFunc(emptyTx.RollupCostData())
+
+ require.Equal(t, ecotoneGas, g)
+ require.Equal(t, ecotoneFee, c)
+
+ // make sure wrong amont of data results in error
+ data = append(data, 0x00) // tack on garbage byte
+ _, err = extractL1GasParamsPostEcotone(data)
+ require.Error(t, err)
+}
+
+func TestExtractFjordGasParams(t *testing.T) {
+ zeroTime := uint64(0)
+ // create a config where fjord is active
+ config := ¶ms.ChainConfig{
+ Optimism: params.OptimismTestConfig.Optimism,
+ RegolithTime: &zeroTime,
+ EcotoneTime: &zeroTime,
+ FjordTime: &zeroTime,
+ }
+ require.True(t, config.IsOptimismFjord(zeroTime))
+
+ data := getEcotoneL1Attributes(
+ baseFee,
+ blobBaseFee,
+ baseFeeScalar,
+ blobBaseFeeScalar,
+ )
+
+ gasparams, err := extractL1GasParams(config, zeroTime, data)
+ require.NoError(t, err)
+ costFunc := gasparams.costFunc
+
+ c, g := costFunc(emptyTx.RollupCostData())
+
+ require.Equal(t, minimumFjordGas, g)
+ require.Equal(t, fjordFee, c)
+}
+
+// make sure the first block of the ecotone upgrade is properly detected, and invokes the bedrock
+// cost function appropriately
+func TestFirstBlockEcotoneGasParams(t *testing.T) {
+ zeroTime := uint64(0)
+ // create a config where ecotone upgrade is active
+ config := ¶ms.ChainConfig{
+ Optimism: params.OptimismTestConfig.Optimism,
+ RegolithTime: &zeroTime,
+ EcotoneTime: &zeroTime,
+ }
+ require.True(t, config.IsOptimismEcotone(0))
+
+ data := getBedrockL1Attributes(baseFee, overhead, scalar)
+
+ gasparams, err := extractL1GasParams(config, zeroTime, data)
+ require.NoError(t, err)
+ oldCostFunc := gasparams.costFunc
+ c, g := oldCostFunc(emptyTx.RollupCostData())
+ require.Equal(t, regolithGas, g)
+ require.Equal(t, regolithFee, c)
+}
+
+func getBedrockL1Attributes(baseFee, overhead, scalar *big.Int) []byte {
+ uint256 := make([]byte, 32)
+ ignored := big.NewInt(1234)
+ data := []byte{}
+ data = append(data, BedrockL1AttributesSelector...)
+ data = append(data, ignored.FillBytes(uint256)...) // arg 0
+ data = append(data, ignored.FillBytes(uint256)...) // arg 1
+ data = append(data, baseFee.FillBytes(uint256)...) // arg 2
+ data = append(data, ignored.FillBytes(uint256)...) // arg 3
+ data = append(data, ignored.FillBytes(uint256)...) // arg 4
+ data = append(data, ignored.FillBytes(uint256)...) // arg 5
+ data = append(data, overhead.FillBytes(uint256)...) // arg 6
+ data = append(data, scalar.FillBytes(uint256)...) // arg 7
+ return data
+}
+
+func getEcotoneL1Attributes(baseFee, blobBaseFee, baseFeeScalar, blobBaseFeeScalar *big.Int) []byte {
+ ignored := big.NewInt(1234)
+ data := []byte{}
+ uint256Slice := make([]byte, 32)
+ uint64Slice := make([]byte, 8)
+ uint32Slice := make([]byte, 4)
+ data = append(data, EcotoneL1AttributesSelector...)
+ data = append(data, baseFeeScalar.FillBytes(uint32Slice)...)
+ data = append(data, blobBaseFeeScalar.FillBytes(uint32Slice)...)
+ data = append(data, ignored.FillBytes(uint64Slice)...)
+ data = append(data, ignored.FillBytes(uint64Slice)...)
+ data = append(data, ignored.FillBytes(uint64Slice)...)
+ data = append(data, baseFee.FillBytes(uint256Slice)...)
+ data = append(data, blobBaseFee.FillBytes(uint256Slice)...)
+ data = append(data, ignored.FillBytes(uint256Slice)...)
+ data = append(data, ignored.FillBytes(uint256Slice)...)
+ return data
+}
+
+type testStateGetter struct {
+ baseFee, blobBaseFee, overhead, scalar *big.Int
+ baseFeeScalar, blobBaseFeeScalar uint32
+}
+
+func (sg *testStateGetter) GetState(addr common.Address, slot common.Hash) common.Hash {
+ buf := common.Hash{}
+ switch slot {
+ case L1BaseFeeSlot:
+ sg.baseFee.FillBytes(buf[:])
+ case OverheadSlot:
+ sg.overhead.FillBytes(buf[:])
+ case ScalarSlot:
+ sg.scalar.FillBytes(buf[:])
+ case L1BlobBaseFeeSlot:
+ sg.blobBaseFee.FillBytes(buf[:])
+ case L1FeeScalarsSlot:
+ // fetch Ecotone fee sclars
+ offset := scalarSectionStart
+ binary.BigEndian.PutUint32(buf[offset:offset+4], sg.baseFeeScalar)
+ binary.BigEndian.PutUint32(buf[offset+4:offset+8], sg.blobBaseFeeScalar)
+ default:
+ panic("unknown slot")
+ }
+ return buf
+}
+
+// TestNewL1CostFunc tests that the appropriate cost function is selected based on the
+// configuration and statedb values.
+func TestNewL1CostFunc(t *testing.T) {
+ time := uint64(10)
+ timeInFuture := uint64(20)
+ config := ¶ms.ChainConfig{
+ Optimism: params.OptimismTestConfig.Optimism,
+ }
+ statedb := &testStateGetter{
+ baseFee: baseFee,
+ overhead: overhead,
+ scalar: scalar,
+ blobBaseFee: blobBaseFee,
+ baseFeeScalar: uint32(baseFeeScalar.Uint64()),
+ blobBaseFeeScalar: uint32(blobBaseFeeScalar.Uint64()),
+ }
+
+ costFunc := NewL1CostFunc(config, statedb)
+ require.NotNil(t, costFunc)
+
+ // empty cost data should result in nil fee
+ fee := costFunc(RollupCostData{}, time)
+ require.Nil(t, fee)
+
+ // emptyTx fee w/ bedrock config should be the bedrock fee
+ fee = costFunc(emptyTx.RollupCostData(), time)
+ require.NotNil(t, fee)
+ require.Equal(t, bedrockFee, fee)
+
+ // emptyTx fee w/ regolith config should be the regolith fee
+ config.RegolithTime = &time
+ costFunc = NewL1CostFunc(config, statedb)
+ require.NotNil(t, costFunc)
+ fee = costFunc(emptyTx.RollupCostData(), time)
+ require.NotNil(t, fee)
+ require.Equal(t, regolithFee, fee)
+
+ // emptyTx fee w/ ecotone config should be the ecotone fee
+ config.EcotoneTime = &time
+ costFunc = NewL1CostFunc(config, statedb)
+ fee = costFunc(emptyTx.RollupCostData(), time)
+ require.NotNil(t, fee)
+ require.Equal(t, ecotoneFee, fee)
+
+ // emptyTx fee w/ fjord config should be the fjord fee
+ config.FjordTime = &time
+ costFunc = NewL1CostFunc(config, statedb)
+ fee = costFunc(emptyTx.RollupCostData(), time)
+ require.NotNil(t, fee)
+ require.Equal(t, fjordFee, fee)
+
+ // emptyTx fee w/ ecotone config, but simulate first ecotone block by blowing away the ecotone
+ // params. Should result in regolith fee.
+ config.FjordTime = &timeInFuture
+ statedb.baseFeeScalar = 0
+ statedb.blobBaseFeeScalar = 0
+ statedb.blobBaseFee = new(big.Int)
+ costFunc = NewL1CostFunc(config, statedb)
+ fee = costFunc(emptyTx.RollupCostData(), time)
+ require.NotNil(t, fee)
+ require.Equal(t, regolithFee, fee)
+
+ // emptyTx fee w/ fjord config, but simulate first ecotone block by blowing away the ecotone
+ // params. Should result in regolith fee.
+ config.EcotoneTime = &time
+ config.FjordTime = &time
+ statedb.baseFeeScalar = 0
+ statedb.blobBaseFeeScalar = 0
+ statedb.blobBaseFee = new(big.Int)
+ costFunc = NewL1CostFunc(config, statedb)
+ fee = costFunc(emptyTx.RollupCostData(), time)
+ require.NotNil(t, fee)
+ require.Equal(t, regolithFee, fee)
+}
+
+func TestFlzCompressLen(t *testing.T) {
+ var (
+ emptyTxBytes, _ = emptyTx.MarshalBinary()
+ contractCallTxStr = "02f901550a758302df1483be21b88304743f94f8" +
+ "0e51afb613d764fa61751affd3313c190a86bb870151bd62fd12adb8" +
+ "e41ef24f3f0000000000000000000000000000000000000000000000" +
+ "00000000000000006e000000000000000000000000af88d065e77c8c" +
+ "c2239327c5edb3a432268e5831000000000000000000000000000000" +
+ "000000000000000000000000000003c1e50000000000000000000000" +
+ "00000000000000000000000000000000000000000000000000000000" +
+ "000000000000000000000000000000000000000000000000a0000000" +
+ "00000000000000000000000000000000000000000000000000000000" +
+ "148c89ed219d02f1a5be012c689b4f5b731827bebe00000000000000" +
+ "0000000000c001a033fd89cb37c31b2cba46b6466e040c61fc9b2a36" +
+ "75a7f5f493ebd5ad77c497f8a07cdf65680e238392693019b4092f61" +
+ "0222e71b7cec06449cb922b93b6a12744e"
+ contractCallTx, _ = hex.DecodeString(contractCallTxStr)
+ )
+
+ testCases := []struct {
+ input []byte
+ expectedLen uint32
+ }{
+ // empty input
+ {[]byte{}, 0},
+ // all 1 inputs
+ {bytes.Repeat([]byte{1}, 1000), 21},
+ // all 0 inputs
+ {make([]byte, 1000), 21},
+ // empty tx input
+ {emptyTxBytes, 31},
+ // contract call tx: https://optimistic.etherscan.io/tx/0x8eb9dd4eb6d33f4dc25fb015919e4b1e9f7542f9b0322bf6622e268cd116b594
+ {contractCallTx, 202},
+ }
+
+ for _, tc := range testCases {
+ output := FlzCompressLen(tc.input)
+ require.Equal(t, tc.expectedLen, output)
+ }
+}
diff --git go-ethereum/core/types/transaction_marshalling_test.go op-geth/core/types/transaction_marshalling_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..19137fba9cb7f4e90c2b8bf57389458ee44a99e6
--- /dev/null
+++ op-geth/core/types/transaction_marshalling_test.go
@@ -0,0 +1,103 @@
+package types
+
+import (
+ "encoding/json"
+ "math/big"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+ "github.com/tenderly/op-geth/common"
+)
+
+func TestTransactionUnmarshalJsonDeposit(t *testing.T) {
+ tx := NewTx(&DepositTx{
+ SourceHash: common.HexToHash("0x1234"),
+ IsSystemTransaction: true,
+ Mint: big.NewInt(34),
+ })
+ json, err := tx.MarshalJSON()
+ require.NoError(t, err, "Failed to marshal tx JSON")
+
+ got := &Transaction{}
+ err = got.UnmarshalJSON(json)
+ require.NoError(t, err, "Failed to unmarshal tx JSON")
+ require.Equal(t, tx.Hash(), got.Hash())
+}
+
+func TestTransactionUnmarshalJSON(t *testing.T) {
+ tests := []struct {
+ name string
+ json string
+ expectedError string
+ }{
+ {
+ name: "No gas",
+ json: `{"type":"0x7e","nonce":null,"gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ expectedError: "missing required field 'gas'",
+ },
+ {
+ name: "No value",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ expectedError: "missing required field 'value'",
+ },
+ {
+ name: "No input",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ expectedError: "missing required field 'input'",
+ },
+ {
+ name: "No from",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ expectedError: "missing required field 'from'",
+ },
+ {
+ name: "No sourceHash",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"from":"0x0000000000000000000000000000000000000001","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ expectedError: "missing required field 'sourceHash'",
+ },
+ {
+ name: "No mint",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ // Allowed
+ },
+ {
+ name: "No IsSystemTx",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ // Allowed
+ },
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ var parsedTx = &Transaction{}
+ err := json.Unmarshal([]byte(test.json), &parsedTx)
+ if test.expectedError == "" {
+ require.NoError(t, err)
+ } else {
+ require.ErrorContains(t, err, test.expectedError)
+ }
+ })
+ }
+
+ tests = []struct {
+ name string
+ json string
+ expectedError string
+ }{
+ {
+ name: "Valid deposit sender",
+ json: `{"type":"0x7e","nonce":"0x1","gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ },
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ var parsedTx = &Transaction{}
+ err := json.Unmarshal([]byte(test.json), &parsedTx)
+ require.NoError(t, err)
+
+ signer := NewLondonSigner(big.NewInt(123))
+ sender, err := signer.Sender(parsedTx)
+ require.NoError(t, err)
+ require.Equal(t, common.HexToAddress("0x1"), sender)
+ })
+ }
+}
diff --git go-ethereum/core/types/transaction_signing_test.go op-geth/core/types/transaction_signing_test.go
index b66577f7ed5de6b0cca5747744cd8dbfda4445eb..ca144217289aec06d6f9024103eef7c98237fa20 100644
--- go-ethereum/core/types/transaction_signing_test.go
+++ op-geth/core/types/transaction_signing_test.go
@@ -22,10 +22,10 @@ "fmt"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
func TestEIP155Signing(t *testing.T) {
diff --git go-ethereum/core/types/transaction_test.go op-geth/core/types/transaction_test.go
index 76a010d2e502b95e6a57685ba08f4763effc8e73..7a3c1e16bccea58c9fe00d2046ff08bebc10ee8c 100644
--- go-ethereum/core/types/transaction_test.go
+++ op-geth/core/types/transaction_test.go
@@ -26,9 +26,9 @@ "math/big"
"reflect"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
)
// The values in those tests are from the Transaction Tests
diff --git go-ethereum/core/types/tx_blob_test.go op-geth/core/types/tx_blob_test.go
index 25d09e31ce4ae9970a9e202cdeb6a65927e772d3..53c89a3fefe23f7c7595a22694ffcaf2ee115276 100644
--- go-ethereum/core/types/tx_blob_test.go
+++ op-geth/core/types/tx_blob_test.go
@@ -4,10 +4,10 @@ import (
"crypto/ecdsa"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
)
// This test verifies that tx.Hash() is not affected by presence of a BlobTxSidecar.
diff --git go-ethereum/core/types/types_test.go op-geth/core/types/types_test.go
index 1fb386d5deef2ce07bdb59097097cec1eb2b716e..7004a6c386fbf11ef6499ee7bbc520268a71a0e9 100644
--- go-ethereum/core/types/types_test.go
+++ op-geth/core/types/types_test.go
@@ -20,9 +20,9 @@ import (
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
)
type devnull struct{ len int }
diff --git go-ethereum/core/vm/analysis_test.go op-geth/core/vm/analysis_test.go
index 398861f8ae7d3056210f79872ffce4a9a4510e4e..50d3413e531ecee5124d0f528c7e4c1861fa1506 100644
--- go-ethereum/core/vm/analysis_test.go
+++ op-geth/core/vm/analysis_test.go
@@ -20,7 +20,7 @@ import (
"math/bits"
"testing"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/crypto"
)
func TestJumpDestAnalysis(t *testing.T) {
diff --git go-ethereum/core/vm/contracts_fuzz_test.go op-geth/core/vm/contracts_fuzz_test.go
index 87c1fff7cc81d919b21585b33194494961d9be24..82e13c2f12fc23270f7e49ecbf16568153998cb5 100644
--- go-ethereum/core/vm/contracts_fuzz_test.go
+++ op-geth/core/vm/contracts_fuzz_test.go
@@ -19,7 +19,7 @@
import (
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
func FuzzPrecompiledContracts(f *testing.F) {
diff --git go-ethereum/core/vm/contracts_test.go op-geth/core/vm/contracts_test.go
index fc30541d459604f6a47c9a0819d4704e8ad8ec92..9c37c974dfff158e4c1020ab3aeb33a84834903f 100644
--- go-ethereum/core/vm/contracts_test.go
+++ op-geth/core/vm/contracts_test.go
@@ -24,7 +24,7 @@ "os"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// precompiledTest defines the input/output pairs for precompiled contract tests.
@@ -57,6 +57,8 @@ common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{},
common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{},
common.BytesToAddress([]byte{9}): &blake2F{},
common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{},
+
+ common.BytesToAddress([]byte{0x01, 0x00}): &p256Verify{},
common.BytesToAddress([]byte{0x0f, 0x0a}): &bls12381G1Add{},
common.BytesToAddress([]byte{0x0f, 0x0b}): &bls12381G1Mul{},
@@ -395,3 +397,15 @@ NoBenchmark: false,
}
benchmarkPrecompiled("0f", testcase, b)
}
+
+// Benchmarks the sample inputs from the P256VERIFY precompile.
+func BenchmarkPrecompiledP256Verify(bench *testing.B) {
+ t := precompiledTest{
+ Input: "4cee90eb86eaa050036147a12d49004b6b9c72bd725d39d4785011fe190f0b4da73bd4903f0ce3b639bbbf6e8e80d16931ff4bcf5993d58468e8fb19086e8cac36dbcd03009df8c59286b162af3bd7fcc0450c9aa81be5d10d312af6c66b1d604aebd3099c618202fcfe16ae7770b0c49ab5eadf74b754204a3bb6060e44eff37618b065f9832de4ca6ca971a7a1adc826d0f7c00181a5fb2ddf79ae00b4e10e",
+ Expected: "0000000000000000000000000000000000000000000000000000000000000001",
+ Name: "p256Verify",
+ }
+ benchmarkPrecompiled("100", t, bench)
+}
+
+func TestPrecompiledP256Verify(t *testing.T) { testJson("p256Verify", "100", t) }
diff --git go-ethereum/core/vm/gas_table_test.go op-geth/core/vm/gas_table_test.go
index 4a2545b6edfaf06795f7015e3b337eef73b4de83..b1083720333b3a049960f262c842ac4e2dfa30ad 100644
--- go-ethereum/core/vm/gas_table_test.go
+++ op-geth/core/vm/gas_table_test.go
@@ -23,13 +23,13 @@ "math/big"
"sort"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
func TestMemoryGasCost(t *testing.T) {
@@ -117,7 +117,7 @@ gasUsed uint64
minimumGas uint64
}{
// legacy create(0, 0, 0xc000) without 3860 used
- {"0x61C00060006000f0" + "600052" + "60206000F3", false, 41237, 41237},
+ {"0x61C00060006000f0" + "600052" + "60206000F3", false, 41237, 41237}, //nolint:all
// legacy create(0, 0, 0xc000) _with_ 3860
{"0x61C00060006000f0" + "600052" + "60206000F3", true, 44309, 44309},
// create2(0, 0, 0xc001, 0) without 3860
diff --git go-ethereum/core/vm/instructions_test.go op-geth/core/vm/instructions_test.go
index 8653864d11e4340c911ddfe5b2ba0fa0256a0214..6d5300e20cf4a90ee3be430d20fa51f744e526d3 100644
--- go-ethereum/core/vm/instructions_test.go
+++ op-geth/core/vm/instructions_test.go
@@ -25,14 +25,14 @@ "os"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
)
type TwoOperandTestcase struct {
diff --git go-ethereum/core/vm/interpreter_test.go op-geth/core/vm/interpreter_test.go
index ff4977d728ed17d65279c81400b7d371ba9c3684..1c9f1d0131d85885d5b4ce11a22f5ef4a6a91e4e 100644
--- go-ethereum/core/vm/interpreter_test.go
+++ op-geth/core/vm/interpreter_test.go
@@ -20,13 +20,13 @@ import (
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
var loopInterruptTests = []string{
diff --git go-ethereum/core/vm/memory_test.go op-geth/core/vm/memory_test.go
index ba36f8023c6ddb017246adfaaec9a45f3998ae3b..8b057e7d12fcb3e6b27fdb6d1e01c41da54ceaae 100644
--- go-ethereum/core/vm/memory_test.go
+++ op-geth/core/vm/memory_test.go
@@ -5,7 +5,7 @@ "bytes"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
func TestMemoryCopy(t *testing.T) {
diff --git go-ethereum/core/vm/runtime/runtime_example_test.go op-geth/core/vm/runtime/runtime_example_test.go
index b7d0ddc384eaab0f0c4d9ba04838d3b1907a20e4..51a8899470d7fd8e345791260e7458983c3a7e7e 100644
--- go-ethereum/core/vm/runtime/runtime_example_test.go
+++ op-geth/core/vm/runtime/runtime_example_test.go
@@ -19,8 +19,8 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/vm/runtime"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/vm/runtime"
)
func ExampleExecute() {
diff --git go-ethereum/core/vm/runtime/runtime_test.go op-geth/core/vm/runtime/runtime_test.go
index b9e3c8ed661cb1873edcb3809ddfbf294b309c3d..5acb4acefb82749af15b139eee55e0f5c091984d 100644
--- go-ethereum/core/vm/runtime/runtime_test.go
+++ op-geth/core/vm/runtime/runtime_test.go
@@ -23,22 +23,22 @@ "os"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/asm"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
- "github.com/ethereum/go-ethereum/eth/tracers/logger"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/accounts/abi"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/asm"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/eth/tracers/logger"
+ "github.com/tenderly/op-geth/params"
// force-load js tracers to trigger registration
- _ "github.com/ethereum/go-ethereum/eth/tracers/js"
"github.com/holiman/uint256"
+ _ "github.com/tenderly/op-geth/eth/tracers/js"
)
func TestDefaults(t *testing.T) {
@@ -600,7 +600,7 @@ }
// TestColdAccountAccessCost test that the cold account access cost is reported
// correctly
-// see: https://github.com/ethereum/go-ethereum/issues/22649
+// see: https://github.com/tenderly/op-geth/issues/22649
func TestColdAccountAccessCost(t *testing.T) {
for i, tc := range []struct {
code []byte
diff --git go-ethereum/crypto/bls12381/g1_test.go op-geth/crypto/bls12381/g1_test.go
index 87140459fbc57c14dcb82c9c54c4f5e673d231ac..538740638d7f43ba9da08650d0d95e21021746a5 100644
--- go-ethereum/crypto/bls12381/g1_test.go
+++ op-geth/crypto/bls12381/g1_test.go
@@ -6,7 +6,7 @@ "crypto/rand"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
func (g *G1) one() *PointG1 {
diff --git go-ethereum/crypto/bls12381/g2_test.go op-geth/crypto/bls12381/g2_test.go
index 4d1f3a19ac67756f58a872924044e71e8df7c8b1..8ef954d0fb704fde6e989a33b9db83fe36086c9c 100644
--- go-ethereum/crypto/bls12381/g2_test.go
+++ op-geth/crypto/bls12381/g2_test.go
@@ -6,7 +6,7 @@ "crypto/rand"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
func (g *G2) one() *PointG2 {
diff --git go-ethereum/crypto/bls12381/pairing_test.go op-geth/crypto/bls12381/pairing_test.go
index 77676fe9b1f385cfbc32d2e7f29ecd949937b57f..a4db440d6d380b0a29c36c5b65ea19240bf217df 100644
--- go-ethereum/crypto/bls12381/pairing_test.go
+++ op-geth/crypto/bls12381/pairing_test.go
@@ -4,7 +4,7 @@ import (
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
func TestPairingExpected(t *testing.T) {
diff --git go-ethereum/crypto/crypto_test.go op-geth/crypto/crypto_test.go
index da123cf980a8579f7b063ec2997d7191d32526ee..a8881fcbaefd72ae0841922ab4e6da704558babe 100644
--- go-ethereum/crypto/crypto_test.go
+++ op-geth/crypto/crypto_test.go
@@ -25,8 +25,8 @@ "os"
"reflect"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var testAddrHex = "970e8128ab834e8eac17ab8e3812f010678cf791"
diff --git go-ethereum/crypto/ecies/ecies_test.go op-geth/crypto/ecies/ecies_test.go
index e3da71010edd60734f44cc818d5dfe712d4d89c1..e84982be5e067f2172014ebb2951a24884b0ec0a 100644
--- go-ethereum/crypto/ecies/ecies_test.go
+++ op-geth/crypto/ecies/ecies_test.go
@@ -39,7 +39,7 @@ "errors"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/crypto"
)
func TestKDF(t *testing.T) {
diff --git go-ethereum/crypto/secp256k1/secp256_test.go op-geth/crypto/secp256k1/secp256_test.go
deleted file mode 100644
index 74408d06d2bf60f16e384bb5595817bb65fd2d29..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/secp256_test.go
+++ /dev/null
@@ -1,241 +0,0 @@
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be found in
-// the LICENSE file.
-
-//go:build !gofuzz && cgo
-// +build !gofuzz,cgo
-
-package secp256k1
-
-import (
- "bytes"
- "crypto/ecdsa"
- "crypto/elliptic"
- "crypto/rand"
- "encoding/hex"
- "io"
- "testing"
-)
-
-const TestCount = 1000
-
-func generateKeyPair() (pubkey, privkey []byte) {
- key, err := ecdsa.GenerateKey(S256(), rand.Reader)
- if err != nil {
- panic(err)
- }
- pubkey = elliptic.Marshal(S256(), key.X, key.Y)
-
- privkey = make([]byte, 32)
- blob := key.D.Bytes()
- copy(privkey[32-len(blob):], blob)
-
- return pubkey, privkey
-}
-
-func csprngEntropy(n int) []byte {
- buf := make([]byte, n)
- if _, err := io.ReadFull(rand.Reader, buf); err != nil {
- panic("reading from crypto/rand failed: " + err.Error())
- }
- return buf
-}
-
-func randSig() []byte {
- sig := csprngEntropy(65)
- sig[32] &= 0x70
- sig[64] %= 4
- return sig
-}
-
-// tests for malleability
-// highest bit of signature ECDSA s value must be 0, in the 33th byte
-func compactSigCheck(t *testing.T, sig []byte) {
- var b = int(sig[32])
- if b < 0 {
- t.Errorf("highest bit is negative: %d", b)
- }
- if ((b >> 7) == 1) != ((b & 0x80) == 0x80) {
- t.Errorf("highest bit: %d bit >> 7: %d", b, b>>7)
- }
- if (b & 0x80) == 0x80 {
- t.Errorf("highest bit: %d bit & 0x80: %d", b, b&0x80)
- }
-}
-
-func TestSignatureValidity(t *testing.T) {
- pubkey, seckey := generateKeyPair()
- msg := csprngEntropy(32)
- sig, err := Sign(msg, seckey)
- if err != nil {
- t.Errorf("signature error: %s", err)
- }
- compactSigCheck(t, sig)
- if len(pubkey) != 65 {
- t.Errorf("pubkey length mismatch: want: 65 have: %d", len(pubkey))
- }
- if len(seckey) != 32 {
- t.Errorf("seckey length mismatch: want: 32 have: %d", len(seckey))
- }
- if len(sig) != 65 {
- t.Errorf("sig length mismatch: want: 65 have: %d", len(sig))
- }
- recid := int(sig[64])
- if recid > 4 || recid < 0 {
- t.Errorf("sig recid mismatch: want: within 0 to 4 have: %d", int(sig[64]))
- }
-}
-
-func TestInvalidRecoveryID(t *testing.T) {
- _, seckey := generateKeyPair()
- msg := csprngEntropy(32)
- sig, _ := Sign(msg, seckey)
- sig[64] = 99
- _, err := RecoverPubkey(msg, sig)
- if err != ErrInvalidRecoveryID {
- t.Fatalf("got %q, want %q", err, ErrInvalidRecoveryID)
- }
-}
-
-func TestSignAndRecover(t *testing.T) {
- pubkey1, seckey := generateKeyPair()
- msg := csprngEntropy(32)
- sig, err := Sign(msg, seckey)
- if err != nil {
- t.Errorf("signature error: %s", err)
- }
- pubkey2, err := RecoverPubkey(msg, sig)
- if err != nil {
- t.Errorf("recover error: %s", err)
- }
- if !bytes.Equal(pubkey1, pubkey2) {
- t.Errorf("pubkey mismatch: want: %x have: %x", pubkey1, pubkey2)
- }
-}
-
-func TestSignDeterministic(t *testing.T) {
- _, seckey := generateKeyPair()
- msg := make([]byte, 32)
- copy(msg, "hi there")
-
- sig1, err := Sign(msg, seckey)
- if err != nil {
- t.Fatal(err)
- }
- sig2, err := Sign(msg, seckey)
- if err != nil {
- t.Fatal(err)
- }
- if !bytes.Equal(sig1, sig2) {
- t.Fatal("signatures not equal")
- }
-}
-
-func TestRandomMessagesWithSameKey(t *testing.T) {
- pubkey, seckey := generateKeyPair()
- keys := func() ([]byte, []byte) {
- return pubkey, seckey
- }
- signAndRecoverWithRandomMessages(t, keys)
-}
-
-func TestRandomMessagesWithRandomKeys(t *testing.T) {
- keys := func() ([]byte, []byte) {
- pubkey, seckey := generateKeyPair()
- return pubkey, seckey
- }
- signAndRecoverWithRandomMessages(t, keys)
-}
-
-func signAndRecoverWithRandomMessages(t *testing.T, keys func() ([]byte, []byte)) {
- for i := 0; i < TestCount; i++ {
- pubkey1, seckey := keys()
- msg := csprngEntropy(32)
- sig, err := Sign(msg, seckey)
- if err != nil {
- t.Fatalf("signature error: %s", err)
- }
- if sig == nil {
- t.Fatal("signature is nil")
- }
- compactSigCheck(t, sig)
-
- // TODO: why do we flip around the recovery id?
- sig[len(sig)-1] %= 4
-
- pubkey2, err := RecoverPubkey(msg, sig)
- if err != nil {
- t.Fatalf("recover error: %s", err)
- }
- if pubkey2 == nil {
- t.Error("pubkey is nil")
- }
- if !bytes.Equal(pubkey1, pubkey2) {
- t.Fatalf("pubkey mismatch: want: %x have: %x", pubkey1, pubkey2)
- }
- }
-}
-
-func TestRecoveryOfRandomSignature(t *testing.T) {
- pubkey1, _ := generateKeyPair()
- msg := csprngEntropy(32)
-
- for i := 0; i < TestCount; i++ {
- // recovery can sometimes work, but if so should always give wrong pubkey
- pubkey2, _ := RecoverPubkey(msg, randSig())
- if bytes.Equal(pubkey1, pubkey2) {
- t.Fatalf("iteration: %d: pubkey mismatch: do NOT want %x: ", i, pubkey2)
- }
- }
-}
-
-func TestRandomMessagesAgainstValidSig(t *testing.T) {
- pubkey1, seckey := generateKeyPair()
- msg := csprngEntropy(32)
- sig, _ := Sign(msg, seckey)
-
- for i := 0; i < TestCount; i++ {
- msg = csprngEntropy(32)
- pubkey2, _ := RecoverPubkey(msg, sig)
- // recovery can sometimes work, but if so should always give wrong pubkey
- if bytes.Equal(pubkey1, pubkey2) {
- t.Fatalf("iteration: %d: pubkey mismatch: do NOT want %x: ", i, pubkey2)
- }
- }
-}
-
-// Useful when the underlying libsecp256k1 API changes to quickly
-// check only recover function without use of signature function
-func TestRecoverSanity(t *testing.T) {
- msg, _ := hex.DecodeString("ce0677bb30baa8cf067c88db9811f4333d131bf8bcf12fe7065d211dce971008")
- sig, _ := hex.DecodeString("90f27b8b488db00b00606796d2987f6a5f59ae62ea05effe84fef5b8b0e549984a691139ad57a3f0b906637673aa2f63d1f55cb1a69199d4009eea23ceaddc9301")
- pubkey1, _ := hex.DecodeString("04e32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a0a2b2667f7e725ceea70c673093bf67663e0312623c8e091b13cf2c0f11ef652")
- pubkey2, err := RecoverPubkey(msg, sig)
- if err != nil {
- t.Fatalf("recover error: %s", err)
- }
- if !bytes.Equal(pubkey1, pubkey2) {
- t.Errorf("pubkey mismatch: want: %x have: %x", pubkey1, pubkey2)
- }
-}
-
-func BenchmarkSign(b *testing.B) {
- _, seckey := generateKeyPair()
- msg := csprngEntropy(32)
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- Sign(msg, seckey)
- }
-}
-
-func BenchmarkRecover(b *testing.B) {
- msg := csprngEntropy(32)
- _, seckey := generateKeyPair()
- sig, _ := Sign(msg, seckey)
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- RecoverPubkey(msg, sig)
- }
-}
diff --git go-ethereum/crypto/signature_test.go op-geth/crypto/signature_test.go
index aecff76bfbda408d928a6441f025e7c0ec2c67e0..1d0fd12dea14ecce4b60a31fcbdc9aa78b1fef02 100644
--- go-ethereum/crypto/signature_test.go
+++ op-geth/crypto/signature_test.go
@@ -22,9 +22,9 @@ "crypto/ecdsa"
"reflect"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
)
var (
diff --git go-ethereum/crypto/signify/signify_test.go op-geth/crypto/signify/signify_test.go
index 9bac2c825f2c844bff70f7566bbe3d953a16f583..56195649dfb3b2ccfcc3e5239bae8bd33d28796a 100644
--- go-ethereum/crypto/signify/signify_test.go
+++ op-geth/crypto/signify/signify_test.go
@@ -48,7 +48,7 @@ if err = tmpFile.Close(); err != nil {
t.Fatal(err)
}
- err = SignFile(tmpFile.Name(), tmpFile.Name()+".sig", testSecKey, "clé", "croissants")
+ err = SignFile(tmpFile.Name(), tmpFile.Name()+".sig", testSecKey, "clé", "croissants") //nolint:all
if err != nil {
t.Fatal(err)
}
diff --git go-ethereum/eth/api_debug_test.go op-geth/eth/api_debug_test.go
index 671e935beb13694195216f77b6d8d21be88cd798..d50e89e275fb8aef26e4af95ef2eb13ce5c8db47 100644
--- go-ethereum/eth/api_debug_test.go
+++ op-geth/eth/api_debug_test.go
@@ -24,13 +24,13 @@ "strings"
"testing"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/triedb"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/triedb"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/eth/catalyst/api_test.go op-geth/eth/catalyst/api_test.go
index cc1258ca55bfcc38afcbeeef10add0727603734e..3c906503a6cdea40fed12143955f28f9b0fe553a 100644
--- go-ethereum/eth/catalyst/api_test.go
+++ op-geth/eth/catalyst/api_test.go
@@ -28,27 +28,29 @@ "sync"
"testing"
"time"
- "github.com/ethereum/go-ethereum/beacon/engine"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/consensus"
- beaconConsensus "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/miner"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/stretchr/testify/require"
+
"github.com/mattn/go-colorable"
+ "github.com/tenderly/op-geth/beacon/engine"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus"
+ beaconConsensus "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/miner"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
+ "github.com/tenderly/op-geth/trie"
)
var (
@@ -198,12 +200,10 @@ HeadBlockHash: blocks[8].Hash(),
SafeBlockHash: common.Hash{},
FinalizedBlockHash: common.Hash{},
}
- _, err := api.ForkchoiceUpdatedV1(fcState, &blockParams)
+ resp, err := api.ForkchoiceUpdatedV1(fcState, &blockParams)
if err != nil {
t.Fatalf("error preparing payload, err=%v", err)
}
- // give the payload some time to be built
- time.Sleep(100 * time.Millisecond)
payloadID := (&miner.BuildPayloadArgs{
Parent: fcState.HeadBlockHash,
Timestamp: blockParams.Timestamp,
@@ -212,6 +212,8 @@ Random: blockParams.Random,
BeaconRoot: blockParams.BeaconRoot,
Version: engine.PayloadV1,
}).Id()
+ require.Equal(t, payloadID, *resp.PayloadID)
+ require.NoError(t, waitForApiPayloadToBuild(api, *resp.PayloadID))
execData, err := api.GetPayloadV1(payloadID)
if err != nil {
t.Fatalf("error getting payload, err=%v", err)
@@ -435,6 +437,11 @@ }
// startEthService creates a full node instance for testing.
func startEthService(t *testing.T, genesis *core.Genesis, blocks []*types.Block) (*node.Node, *eth.Ethereum) {
+ ethcfg := ðconfig.Config{Genesis: genesis, SyncMode: downloader.FullSync, TrieTimeout: time.Minute, TrieDirtyCache: 256, TrieCleanCache: 256}
+ return startEthServiceWithConfigFn(t, blocks, ethcfg)
+}
+
+func startEthServiceWithConfigFn(t *testing.T, blocks []*types.Block, ethcfg *ethconfig.Config) (*node.Node, *eth.Ethereum) {
t.Helper()
n, err := node.New(&node.Config{
@@ -447,7 +454,7 @@ if err != nil {
t.Fatal("can't create node:", err)
}
- ethcfg := ðconfig.Config{Genesis: genesis, SyncMode: downloader.FullSync, TrieTimeout: time.Minute, TrieDirtyCache: 256, TrieCleanCache: 256}
+ // default eth config is moved to startEthService
ethservice, err := eth.New(n, ethcfg)
if err != nil {
t.Fatal("can't create eth service:", err)
@@ -628,8 +635,7 @@ }
if resp.PayloadStatus.Status != engine.VALID {
t.Fatalf("error preparing payload, invalid status: %v", resp.PayloadStatus.Status)
}
- // give the payload some time to be built
- time.Sleep(50 * time.Millisecond)
+ require.NoError(t, waitForApiPayloadToBuild(api, *resp.PayloadID))
if payload, err = api.GetPayloadV1(*resp.PayloadID); err != nil {
t.Fatalf("can't get payload: %v", err)
}
@@ -677,6 +683,7 @@ payload, err := api.eth.Miner().BuildPayload(args)
if err != nil {
return nil, err
}
+ waitForPayloadToBuild(payload)
return payload.ResolveFull().ExecutionPayload, nil
}
@@ -915,6 +922,7 @@ payload, err := api.eth.Miner().BuildPayload(args)
if err != nil {
t.Fatalf("error preparing payload, err=%v", err)
}
+ waitForPayloadToBuild(payload)
data := *payload.Resolve().ExecutionPayload
// We need to recompute the blockhash, since the miner computes a wrong (correct) blockhash
txs, _ := decodeTransactions(data.Transactions)
@@ -1076,6 +1084,8 @@ Withdrawals: blockParams.Withdrawals,
BeaconRoot: blockParams.BeaconRoot,
Version: engine.PayloadV2,
}).Id()
+ require.Equal(t, payloadID, *resp.PayloadID)
+ require.NoError(t, waitForApiPayloadToBuild(api, payloadID))
execData, err := api.GetPayloadV2(payloadID)
if err != nil {
t.Fatalf("error getting payload, err=%v", err)
@@ -1110,7 +1120,7 @@ },
},
}
fcState.HeadBlockHash = execData.ExecutionPayload.BlockHash
- _, err = api.ForkchoiceUpdatedV2(fcState, &blockParams)
+ resp, err = api.ForkchoiceUpdatedV2(fcState, &blockParams)
if err != nil {
t.Fatalf("error preparing payload, err=%v", err)
}
@@ -1125,6 +1135,8 @@ Withdrawals: blockParams.Withdrawals,
BeaconRoot: blockParams.BeaconRoot,
Version: engine.PayloadV2,
}).Id()
+ require.Equal(t, payloadID, *resp.PayloadID)
+ require.NoError(t, waitForApiPayloadToBuild(api, payloadID))
execData, err = api.GetPayloadV2(payloadID)
if err != nil {
t.Fatalf("error getting payload, err=%v", err)
@@ -1265,6 +1277,8 @@ Parent: fcState.HeadBlockHash,
Timestamp: test.blockParams.Timestamp,
FeeRecipient: test.blockParams.SuggestedFeeRecipient,
Random: test.blockParams.Random,
+ BeaconRoot: test.blockParams.BeaconRoot,
+ Withdrawals: test.blockParams.Withdrawals,
Version: payloadVersion,
}).Id()
execData, err := api.GetPayloadV2(payloadID)
@@ -1622,6 +1636,8 @@ Withdrawals: blockParams.Withdrawals,
BeaconRoot: blockParams.BeaconRoot,
Version: engine.PayloadV3,
}).Id()
+ require.Equal(t, payloadID, *resp.PayloadID)
+ require.NoError(t, waitForApiPayloadToBuild(api, *resp.PayloadID))
execData, err := api.GetPayloadV3(payloadID)
if err != nil {
t.Fatalf("error getting payload, err=%v", err)
@@ -1659,6 +1675,14 @@ }
if root := db.GetState(params.BeaconRootsStorageAddress, rootIdx); root != *blockParams.BeaconRoot {
t.Fatalf("incorrect root stored: want %s, got %s", *blockParams.BeaconRoot, root)
}
+}
+
+func waitForPayloadToBuild(payload *miner.Payload) {
+ payload.WaitFull()
+}
+
+func waitForApiPayloadToBuild(api *ConsensusAPI, id engine.PayloadID) error {
+ return api.localBlocks.waitFull(id)
}
// TestGetClientVersion verifies the expected version info is returned.
diff --git go-ethereum/eth/catalyst/simulated_beacon_test.go op-geth/eth/catalyst/simulated_beacon_test.go
index 6fa97ad87a2ac79c41fb4a3356452cffd473aaa4..bfbe5f64ccf05343f06c1c53bc419533f8ab0078 100644
--- go-ethereum/eth/catalyst/simulated_beacon_test.go
+++ op-geth/eth/catalyst/simulated_beacon_test.go
@@ -22,16 +22,16 @@ "math/big"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/params"
)
func startSimulatedBeaconEthService(t *testing.T, genesis *core.Genesis) (*node.Node, *eth.Ethereum, *SimulatedBeacon) {
diff --git go-ethereum/eth/catalyst/superchain_test.go op-geth/eth/catalyst/superchain_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..60ac09bfa4ddc6e2ffb8610cca5d6dd09d79f3ef
--- /dev/null
+++ op-geth/eth/catalyst/superchain_test.go
@@ -0,0 +1,120 @@
+package catalyst
+
+import (
+ "testing"
+ "time"
+
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/params"
+)
+
+func TestSignalSuperchainV1(t *testing.T) {
+ genesis, preMergeBlocks := generateMergeChain(2, false)
+ n, ethservice := startEthService(t, genesis, preMergeBlocks)
+ defer n.Close()
+ api := NewConsensusAPI(ethservice)
+ t.Run("matching", func(t *testing.T) {
+ out, err := api.SignalSuperchainV1(&SuperchainSignal{
+ Recommended: params.OPStackSupport,
+ Required: params.OPStackSupport,
+ })
+ if err != nil {
+ t.Fatalf("failed to process signal: %v", err)
+ }
+ if out != params.OPStackSupport {
+ t.Fatalf("expected %s but got %s", params.OPStackSupport, out)
+ }
+ })
+ t.Run("null_arg", func(t *testing.T) {
+ out, err := api.SignalSuperchainV1(nil)
+ if err != nil {
+ t.Fatalf("failed to process signal: %v", err)
+ }
+ if out != params.OPStackSupport {
+ t.Fatalf("expected %s but got %s", params.OPStackSupport, out)
+ }
+ })
+}
+
+func TestSignalSuperchainV1Halt(t *testing.T) {
+ // Note: depending on the params.OPStackSupport some types of bumps are not possible with active prerelease
+ testCases := []struct {
+ cfg string
+ bump string
+ halt bool
+ }{
+ {"none", "major", false},
+ {"major", "major", true},
+ {"minor", "major", true},
+ {"patch", "major", true},
+ {"major", "minor", false},
+ {"minor", "minor", true},
+ {"patch", "minor", true},
+ {"major", "patch", false},
+ {"minor", "patch", false},
+ {"patch", "patch", true},
+ }
+ for _, tc := range testCases {
+ tc := tc
+ t.Run(tc.cfg+"_"+tc.bump, func(t *testing.T) {
+ genesis, preMergeBlocks := generateMergeChain(2, false)
+ ethcfg := ðconfig.Config{Genesis: genesis, SyncMode: downloader.FullSync, TrieTimeout: time.Minute, TrieDirtyCache: 256, TrieCleanCache: 256}
+ ethcfg.RollupHaltOnIncompatibleProtocolVersion = tc.cfg // opt-in to halting (or not)
+ n, ethservice := startEthServiceWithConfigFn(t, preMergeBlocks, ethcfg)
+ defer n.Close() // close at the end, regardless of any prior (failed) closing
+ api := NewConsensusAPI(ethservice)
+ _, build, major, minor, patch, preRelease := params.OPStackSupport.Parse()
+ if preRelease != 0 { // transform back from prerelease, so we can do a clean version bump
+ if patch != 0 {
+ patch -= 1
+ } else if minor != 0 {
+ // can't patch-bump e.g. v3.1.0-1, the prerelease forces a minor bump:
+ // v3.0.999 is lower than the prerelease, v3.1.1-1 is a prerelease of v3.1.1.
+ if tc.bump == "patch" {
+ t.Skip()
+ }
+ minor -= 1
+ } else if major != 0 {
+ if tc.bump == "minor" || tc.bump == "patch" { // can't minor-bump or patch-bump
+ t.Skip()
+ }
+ major -= 1
+ }
+ preRelease = 0
+ }
+ majorSignal, minorSignal, patchSignal := major, minor, patch
+ switch tc.bump {
+ case "major":
+ majorSignal += 1
+ case "minor":
+ minorSignal += 1
+ case "patch":
+ patchSignal += 1
+ }
+ out, err := api.SignalSuperchainV1(&SuperchainSignal{
+ Recommended: params.OPStackSupport, // required version change should be enough
+ Required: params.ProtocolVersionV0{Build: build, Major: majorSignal, Minor: minorSignal, Patch: patchSignal, PreRelease: preRelease}.Encode(),
+ })
+ if err != nil {
+ t.Fatalf("failed to process signal: %v", err)
+ }
+ if out != params.OPStackSupport {
+ t.Fatalf("expected %s but got %s", params.OPStackSupport, out)
+ }
+ closeErr := n.Close()
+ if !tc.halt {
+ // assert no halt by closing, and not getting any error
+ if closeErr != nil {
+ t.Fatalf("expected not to have closed already, but just closed without error")
+ }
+ } else {
+ // assert halt by closing again, and seeing if we are not stopped already
+ if closeErr != node.ErrNodeStopped {
+ t.Fatalf("expected to have already closed and get a ErrNodeStopped error, but got %v", closeErr)
+ }
+ }
+ })
+ }
+}
diff --git go-ethereum/eth/downloader/downloader_test.go op-geth/eth/downloader/downloader_test.go
index 2468e1a9809e247c1dd877a86e8fce37c2f08800..c3fa260be2d013c698834e817de6ed89f56bf711 100644
--- go-ethereum/eth/downloader/downloader_test.go
+++ op-geth/eth/downloader/downloader_test.go
@@ -26,20 +26,20 @@ "sync/atomic"
"testing"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/eth/protocols/snap"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/eth/protocols/snap"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
)
// downloadTester is a test simulator for mocking out local block chain.
@@ -81,7 +81,7 @@ freezer: freezer,
chain: chain,
peers: make(map[string]*downloadTesterPeer),
}
- tester.downloader = New(db, new(event.TypeMux), tester.chain, nil, tester.dropPeer, success)
+ tester.downloader = New(db, new(event.TypeMux), tester.chain, nil, tester.dropPeer, success, 0)
return tester
}
diff --git go-ethereum/eth/downloader/queue_test.go op-geth/eth/downloader/queue_test.go
index 50b9031a27c6cdd04e846396ba19a9ef22452177..ec9962496d2748c0bdaf6b093899228d63ebeafd 100644
--- go-ethereum/eth/downloader/queue_test.go
+++ op-geth/eth/downloader/queue_test.go
@@ -25,13 +25,13 @@ "sync"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie"
"golang.org/x/exp/slog"
)
diff --git go-ethereum/eth/downloader/receiptreference_test.go op-geth/eth/downloader/receiptreference_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..5793422d6040cc5d1e5cfc016ab2528e38a26d10
--- /dev/null
+++ op-geth/eth/downloader/receiptreference_test.go
@@ -0,0 +1,108 @@
+package downloader
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/tenderly/op-geth/core/types"
+)
+
+// makeCorrection is a helper function to create a slice of receipts and a slice of corrected receipts
+func makeCorrection(bn uint64, cid uint64, ns []uint64, ty []uint8) (types.Receipts, types.Receipts) {
+ receipts := make(types.Receipts, len(ns))
+ correctedReceipts := make(types.Receipts, len(ns))
+ transactions := make(types.Transactions, len(ns))
+ for i := range ns {
+ receipts[i] = &types.Receipt{Type: ty[i], DepositNonce: &ns[i]}
+ correctedReceipts[i] = &types.Receipt{Type: ty[i], DepositNonce: &ns[i]}
+ transactions[i] = types.NewTx(&types.DepositTx{})
+ }
+
+ correctedReceipts = correctReceipts(correctedReceipts, transactions, bn, cid)
+
+ return receipts, correctedReceipts
+}
+
+func TestCorrectReceipts(t *testing.T) {
+ type testcase struct {
+ blockNum uint64
+ chainID uint64
+ nonces []uint64
+ txTypes []uint8
+ validate func(types.Receipts, types.Receipts)
+ }
+
+ // Tests use the real reference data, so block numbers and chainIDs are selected for different test cases
+ testcases := []testcase{
+ // Test case 1: No receipts
+ {
+ blockNum: 6825767,
+ chainID: 420,
+ nonces: []uint64{},
+ txTypes: []uint8{},
+ validate: func(receipts types.Receipts, correctedReceipts types.Receipts) {
+ assert.Empty(t, correctedReceipts)
+ },
+ },
+ // Test case 2: No deposits
+ {
+ blockNum: 6825767,
+ chainID: 420,
+ nonces: []uint64{1, 2, 3},
+ txTypes: []uint8{1, 1, 1},
+ validate: func(receipts types.Receipts, correctedReceipts types.Receipts) {
+ assert.Equal(t, receipts, correctedReceipts)
+ },
+ },
+ // Test case 3: all deposits with no correction
+ {
+ blockNum: 8835769,
+ chainID: 420,
+ nonces: []uint64{78756, 78757, 78758, 78759, 78760, 78761, 78762, 78763, 78764},
+ txTypes: []uint8{126, 126, 126, 126, 126, 126, 126, 126, 126},
+ validate: func(receipts types.Receipts, correctedReceipts types.Receipts) {
+ assert.Equal(t, receipts, correctedReceipts)
+ },
+ },
+ // Test case 4: all deposits with a correction
+ {
+ blockNum: 8835769,
+ chainID: 420,
+ nonces: []uint64{78756, 78757, 78758, 12345, 78760, 78761, 78762, 78763, 78764},
+ txTypes: []uint8{126, 126, 126, 126, 126, 126, 126, 126, 126},
+ validate: func(receipts types.Receipts, correctedReceipts types.Receipts) {
+ assert.NotEqual(t, receipts[3], correctedReceipts[3])
+ for i := range receipts {
+ if i != 3 {
+ assert.Equal(t, receipts[i], correctedReceipts[i])
+ }
+ }
+ },
+ },
+ // Test case 5: deposits with several corrections and non-deposits
+ {
+ blockNum: 8835769,
+ chainID: 420,
+ nonces: []uint64{0, 1, 2, 78759, 78760, 78761, 6, 78763, 78764, 9, 10, 11},
+ txTypes: []uint8{126, 126, 126, 126, 126, 126, 126, 126, 126, 1, 1, 1},
+ validate: func(receipts types.Receipts, correctedReceipts types.Receipts) {
+ // indexes 0, 1, 2, 6 were modified
+ // indexes 9, 10, 11 were added too, but they are not user deposits
+ assert.NotEqual(t, receipts[0], correctedReceipts[0])
+ assert.NotEqual(t, receipts[1], correctedReceipts[1])
+ assert.NotEqual(t, receipts[2], correctedReceipts[2])
+ assert.NotEqual(t, receipts[6], correctedReceipts[6])
+ for i := range receipts {
+ if i != 0 && i != 1 && i != 2 && i != 6 {
+ assert.Equal(t, receipts[i], correctedReceipts[i])
+ }
+ }
+ },
+ },
+ }
+
+ for _, tc := range testcases {
+ receipts, correctedReceipts := makeCorrection(tc.blockNum, tc.chainID, tc.nonces, tc.txTypes)
+ tc.validate(receipts, correctedReceipts)
+ }
+}
diff --git go-ethereum/eth/downloader/skeleton_test.go op-geth/eth/downloader/skeleton_test.go
index 2b108dfe93610f1eec98e4c8d1e436c3ba182704..d5866e24268819c9dbc1d6fa4d8fa89e11de0495 100644
--- go-ethereum/eth/downloader/skeleton_test.go
+++ op-geth/eth/downloader/skeleton_test.go
@@ -25,11 +25,11 @@ "sync/atomic"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/log"
)
// hookedBackfiller is a tester backfiller with all interface methods mocked and
diff --git go-ethereum/eth/downloader/testchain_test.go op-geth/eth/downloader/testchain_test.go
index 46f3febd8ba8194ad7c6f68a5386df6e368901c4..4edca94b81523856957957020897dd5076b253d3 100644
--- go-ethereum/eth/downloader/testchain_test.go
+++ op-geth/eth/downloader/testchain_test.go
@@ -22,15 +22,15 @@ "math/big"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/triedb"
)
// Test chain parameters.
diff --git go-ethereum/eth/fetcher/block_fetcher_test.go op-geth/eth/fetcher/block_fetcher_test.go
index cb7cbaf79edc86dde7b3131d4de497237ba61d69..9eb68aa5fc8299304e55bd72bcf93940b866dea1 100644
--- go-ethereum/eth/fetcher/block_fetcher_test.go
+++ op-geth/eth/fetcher/block_fetcher_test.go
@@ -24,16 +24,16 @@ "sync/atomic"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/triedb"
)
var (
diff --git go-ethereum/eth/fetcher/tx_fetcher_test.go op-geth/eth/fetcher/tx_fetcher_test.go
index 4a62e579b6356308ed6d09349c62ab9159edb10e..3ce0c872a4784750ceae13ccc8d9dab571f645ac 100644
--- go-ethereum/eth/fetcher/tx_fetcher_test.go
+++ op-geth/eth/fetcher/tx_fetcher_test.go
@@ -23,11 +23,11 @@ "math/rand"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
var (
diff --git go-ethereum/eth/filters/api_test.go op-geth/eth/filters/api_test.go
index 822bc826f6b052ed17271316d26c870465a36716..c6c4204014c8bc402baec70d08a959272d6232ae 100644
--- go-ethereum/eth/filters/api_test.go
+++ op-geth/eth/filters/api_test.go
@@ -21,8 +21,8 @@ "encoding/json"
"fmt"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/rpc"
)
func TestUnmarshalJSONNewFilterArgs(t *testing.T) {
diff --git go-ethereum/eth/filters/bench_test.go op-geth/eth/filters/bench_test.go
index 73b96b77af62dc7d2134495d03a71940a5f48dda..d97bc7de93127ae367f1de321ec2a210a9eb9025 100644
--- go-ethereum/eth/filters/bench_test.go
+++ op-geth/eth/filters/bench_test.go
@@ -22,13 +22,13 @@ "fmt"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/bitutil"
- "github.com/ethereum/go-ethereum/core/bloombits"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/node"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/bitutil"
+ "github.com/tenderly/op-geth/core/bloombits"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/node"
)
func BenchmarkBloomBits512(b *testing.B) {
diff --git go-ethereum/eth/filters/filter_system_test.go op-geth/eth/filters/filter_system_test.go
index 99c012cc84f4e068ab1af84cf407f274f1872cf5..d933a453d870a99b0b4bb939218e3bd66f9305f3 100644
--- go-ethereum/eth/filters/filter_system_test.go
+++ op-geth/eth/filters/filter_system_test.go
@@ -27,19 +27,19 @@ "runtime"
"testing"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/bloombits"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/bloombits"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
type testBackend struct {
diff --git go-ethereum/eth/filters/filter_test.go op-geth/eth/filters/filter_test.go
index 659ca5ce197da6511cb03f3b7ac3089c99b18751..f6674a015b16460c4957e935c38a4ce4fd1ec2f8 100644
--- go-ethereum/eth/filters/filter_test.go
+++ op-geth/eth/filters/filter_test.go
@@ -24,17 +24,17 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/accounts/abi"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
+ "github.com/tenderly/op-geth/triedb"
)
func makeReceipt(addr common.Address) *types.Receipt {
diff --git go-ethereum/eth/gasprice/feehistory_test.go op-geth/eth/gasprice/feehistory_test.go
index 1bcfb287a571f117af1b01974b4822a6f56cc2e7..154843de3bacf7ae120b339ddd235e3d5f933498 100644
--- go-ethereum/eth/gasprice/feehistory_test.go
+++ op-geth/eth/gasprice/feehistory_test.go
@@ -22,7 +22,7 @@ "errors"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/rpc"
)
func TestFeeHistory(t *testing.T) {
diff --git go-ethereum/eth/gasprice/gasprice_test.go op-geth/eth/gasprice/gasprice_test.go
index 79217502f79943e64921373b5d9cba5effbd51e0..7696c4eef526256f314054680e3bc0891c39d70f 100644
--- go-ethereum/eth/gasprice/gasprice_test.go
+++ op-geth/eth/gasprice/gasprice_test.go
@@ -22,16 +22,16 @@ "math"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
const testHead = 32
diff --git go-ethereum/eth/gasprice/optimism-gasprice_test.go op-geth/eth/gasprice/optimism-gasprice_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..01876269624bca4efd196d011584bfc4623ee82e
--- /dev/null
+++ op-geth/eth/gasprice/optimism-gasprice_test.go
@@ -0,0 +1,142 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package gasprice
+
+import (
+ "context"
+ "math/big"
+ "testing"
+
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
+ "github.com/tenderly/op-geth/trie"
+)
+
+const (
+ blockGasLimit = params.TxGas * 3
+)
+
+type testTxData struct {
+ priorityFee int64
+ gasLimit uint64
+}
+
+type opTestBackend struct {
+ block *types.Block
+ receipts []*types.Receipt
+}
+
+func (b *opTestBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
+ panic("not implemented")
+}
+
+func (b *opTestBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
+ return b.block, nil
+}
+
+func (b *opTestBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
+ return b.receipts, nil
+}
+
+func (b *opTestBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) {
+ panic("not implemented")
+}
+
+func (b *opTestBackend) ChainConfig() *params.ChainConfig {
+ return params.OptimismTestConfig
+}
+
+func (b *opTestBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription {
+ return nil
+}
+
+func newOpTestBackend(t *testing.T, txs []testTxData) *opTestBackend {
+ var (
+ key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+ signer = types.LatestSigner(params.TestChainConfig)
+ )
+ // only the most recent block is considered for optimism priority fee suggestions, so this is
+ // where we add the test transactions
+ ts := []*types.Transaction{}
+ rs := []*types.Receipt{}
+ header := types.Header{}
+ header.GasLimit = blockGasLimit
+ var nonce uint64
+ for _, tx := range txs {
+ txdata := &types.DynamicFeeTx{
+ ChainID: params.TestChainConfig.ChainID,
+ Nonce: nonce,
+ To: &common.Address{},
+ Gas: params.TxGas,
+ GasFeeCap: big.NewInt(100 * params.GWei),
+ GasTipCap: big.NewInt(tx.priorityFee),
+ Data: []byte{},
+ }
+ t := types.MustSignNewTx(key, signer, txdata)
+ ts = append(ts, t)
+ r := types.Receipt{}
+ r.GasUsed = tx.gasLimit
+ header.GasUsed += r.GasUsed
+ rs = append(rs, &r)
+ nonce++
+ }
+ hasher := trie.NewStackTrie(nil)
+ b := types.NewBlock(&header, ts, nil, nil, hasher)
+ return &opTestBackend{block: b, receipts: rs}
+}
+
+func TestSuggestOptimismPriorityFee(t *testing.T) {
+ minSuggestion := new(big.Int).SetUint64(1e8 * params.Wei)
+ var cases = []struct {
+ txdata []testTxData
+ want *big.Int
+ }{
+ {
+ // block well under capacity, expect min priority fee suggestion
+ txdata: []testTxData{testTxData{params.GWei, 21000}},
+ want: minSuggestion,
+ },
+ {
+ // 2 txs, still under capacity, expect min priority fee suggestion
+ txdata: []testTxData{testTxData{params.GWei, 21000}, testTxData{params.GWei, 21000}},
+ want: minSuggestion,
+ },
+ {
+ // 2 txs w same priority fee (1 gwei), but second tx puts it right over capacity
+ txdata: []testTxData{testTxData{params.GWei, 21000}, testTxData{params.GWei, 21001}},
+ want: big.NewInt(1100000000), // 10 percent over 1 gwei, the median
+ },
+ {
+ // 3 txs, full block. return 10% over the median tx (10 gwei * 10% == 11 gwei)
+ txdata: []testTxData{testTxData{10 * params.GWei, 21000}, testTxData{1 * params.GWei, 21000}, testTxData{100 * params.GWei, 21000}},
+ want: big.NewInt(11 * params.GWei),
+ },
+ }
+ for i, c := range cases {
+ backend := newOpTestBackend(t, c.txdata)
+ oracle := NewOracle(backend, Config{MinSuggestedPriorityFee: minSuggestion})
+ got := oracle.SuggestOptimismPriorityFee(context.Background(), backend.block.Header(), backend.block.Hash())
+ if got.Cmp(c.want) != 0 {
+ t.Errorf("Gas price mismatch for test case %d: want %d, got %d", i, c.want, got)
+ }
+ }
+}
diff --git go-ethereum/eth/handler_eth_test.go op-geth/eth/handler_eth_test.go
index 579ca3c097353e16744a61f8951392c68fcbb2cb..46316655def78bee2358a0b7e907bdc2aa953f3f 100644
--- go-ethereum/eth/handler_eth_test.go
+++ op-geth/eth/handler_eth_test.go
@@ -22,20 +22,20 @@ "math/big"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/forkid"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/forkid"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/params"
)
// testEthHandler is a mock event handler to listen for inbound network requests
diff --git go-ethereum/eth/handler_test.go op-geth/eth/handler_test.go
index 58353f6b6452f7b2bf2497f64cbd17770bd19672..737f7218360b1d89bdfe1a7960d57a552952f68f 100644
--- go-ethereum/eth/handler_test.go
+++ op-geth/eth/handler_test.go
@@ -21,20 +21,20 @@ "math/big"
"sort"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/params"
)
var (
diff --git go-ethereum/eth/protocols/eth/handler_test.go op-geth/eth/protocols/eth/handler_test.go
index fdf551ef210c923466f116e96484afba74cd11fa..bba8d6dfb0805b6886aa308ca4173064a6313a24 100644
--- go-ethereum/eth/protocols/eth/handler_test.go
+++ op-geth/eth/protocols/eth/handler_test.go
@@ -22,21 +22,21 @@ "math/big"
"math/rand"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/txpool/legacypool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/txpool/legacypool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/params"
)
var (
diff --git go-ethereum/eth/protocols/eth/handshake_test.go op-geth/eth/protocols/eth/handshake_test.go
index b9fd13d86303e73b1eef6c805b8d3cb8354334dc..3c01bdf237cfacf16245324c69d07ab3d43fc7da 100644
--- go-ethereum/eth/protocols/eth/handshake_test.go
+++ op-geth/eth/protocols/eth/handshake_test.go
@@ -20,10 +20,10 @@ import (
"errors"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/forkid"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/forkid"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// Tests that handshake failures are detected and reported correctly.
diff --git go-ethereum/eth/protocols/eth/peer_test.go op-geth/eth/protocols/eth/peer_test.go
index efbbbc6fff88961453b4649dbcce5c12406e20e9..e569d9497330f8972b9f0c4d6ad58d5a65fff1e2 100644
--- go-ethereum/eth/protocols/eth/peer_test.go
+++ op-geth/eth/protocols/eth/peer_test.go
@@ -23,9 +23,9 @@ import (
"crypto/rand"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// testPeer is a simulated peer to allow testing direct network calls.
diff --git go-ethereum/eth/protocols/eth/protocol_test.go op-geth/eth/protocols/eth/protocol_test.go
index bc2545dea286a6b8cd633dd5dc54866d7175162f..f7fe6ad358a23755c1338bda2c9f820d30c568f8 100644
--- go-ethereum/eth/protocols/eth/protocol_test.go
+++ op-geth/eth/protocols/eth/protocol_test.go
@@ -21,9 +21,9 @@ "bytes"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rlp"
)
// Tests that the custom union field encoder and decoder works correctly.
diff --git go-ethereum/eth/protocols/snap/gentrie_test.go op-geth/eth/protocols/snap/gentrie_test.go
index 1fb2dbce7568def31422913f761e53f73b59ed44..7c1d62cdf44491afd3f1e8de9e769f22b894897d 100644
--- go-ethereum/eth/protocols/snap/gentrie_test.go
+++ op-geth/eth/protocols/snap/gentrie_test.go
@@ -22,12 +22,12 @@ "math/rand"
"slices"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/internal/testrand"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/internal/testrand"
+ "github.com/tenderly/op-geth/trie"
)
type replayer struct {
diff --git go-ethereum/eth/protocols/snap/handler_fuzzing_test.go op-geth/eth/protocols/snap/handler_fuzzing_test.go
index 4e234ad21b4b11720f890b82be2098b8d98fd562..4fe3ad4e269948063483360703827db915771ff9 100644
--- go-ethereum/eth/protocols/snap/handler_fuzzing_test.go
+++ op-geth/eth/protocols/snap/handler_fuzzing_test.go
@@ -24,17 +24,17 @@ "math/big"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
fuzz "github.com/google/gofuzz"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
func FuzzARange(f *testing.F) {
diff --git go-ethereum/eth/protocols/snap/progress_test.go op-geth/eth/protocols/snap/progress_test.go
index 9d923bd2f5078b62ab75a25ab0a0eeb9d016e07c..2ccaa9d693b73d01b804e478792bd7a41fe08194 100644
--- go-ethereum/eth/protocols/snap/progress_test.go
+++ op-geth/eth/protocols/snap/progress_test.go
@@ -20,7 +20,7 @@ import (
"encoding/json"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// Legacy sync progress definitions
diff --git go-ethereum/eth/protocols/snap/range_test.go op-geth/eth/protocols/snap/range_test.go
index ea643f13612f9e3e577bffd4d7185bd13ca36bc8..915538add3d4ee56f65e5809e8e516c2b96e4ac5 100644
--- go-ethereum/eth/protocols/snap/range_test.go
+++ op-geth/eth/protocols/snap/range_test.go
@@ -19,7 +19,7 @@
import (
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// Tests that given a starting hash and a density, the hash ranger can correctly
diff --git go-ethereum/eth/protocols/snap/sort_test.go op-geth/eth/protocols/snap/sort_test.go
index be0a8c5706968d551b0b43a27084a4987f570bda..9539b7295aa12b3b1e2fa518bc40e0eb50b99523 100644
--- go-ethereum/eth/protocols/snap/sort_test.go
+++ op-geth/eth/protocols/snap/sort_test.go
@@ -21,7 +21,7 @@ "bytes"
"fmt"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
func hexToNibbles(s string) []byte {
diff --git go-ethereum/eth/protocols/snap/sync_test.go op-geth/eth/protocols/snap/sync_test.go
index b780868b4e06579fda6fe88036d5ab3a5bec17f8..aa6ba4807a19c673113a045d3f44c41bd94f6085 100644
--- go-ethereum/eth/protocols/snap/sync_test.go
+++ op-geth/eth/protocols/snap/sync_test.go
@@ -27,19 +27,19 @@ "sync"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/trie/testutil"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/trie/testutil"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
"golang.org/x/crypto/sha3"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/eth/sync_test.go op-geth/eth/sync_test.go
index a31986730f0619304e498958e4fbc41e73cb74d3..2389388e8b95bf43eb5799e6c061dfbc2893b26c 100644
--- go-ethereum/eth/sync_test.go
+++ op-geth/eth/sync_test.go
@@ -20,11 +20,11 @@ import (
"testing"
"time"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/eth/protocols/snap"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/eth/protocols/snap"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// Tests that snap sync is disabled after a successful sync cycle.
diff --git go-ethereum/eth/tracers/internal/tracetest/calltrace_test.go op-geth/eth/tracers/internal/tracetest/calltrace_test.go
index 6216a16ced9c15360961c15a123add09371f46cc..c46eec13cc46d8ceb31f71e00c4150f56aef4e9b 100644
--- go-ethereum/eth/tracers/internal/tracetest/calltrace_test.go
+++ op-geth/eth/tracers/internal/tracetest/calltrace_test.go
@@ -24,17 +24,17 @@ "path/filepath"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/tests"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/tests"
)
type callContext struct {
diff --git go-ethereum/eth/tracers/internal/tracetest/flat_calltrace_test.go op-geth/eth/tracers/internal/tracetest/flat_calltrace_test.go
index abee48891767d5434f65e6a1d64ed22e031a1153..6c70aa22377d4723c1fbdb0e5060ffad563dc972 100644
--- go-ethereum/eth/tracers/internal/tracetest/flat_calltrace_test.go
+++ op-geth/eth/tracers/internal/tracetest/flat_calltrace_test.go
@@ -10,17 +10,16 @@ "reflect"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/tests"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/tests"
// Force-load the native, to trigger registration
- "github.com/ethereum/go-ethereum/eth/tracers"
+ "github.com/tenderly/op-geth/eth/tracers"
)
// flatCallTrace is the result of a callTracerParity run.
@@ -82,7 +81,7 @@ return fmt.Errorf("failed to parse testcase: %v", err)
}
// Configure a blockchain with the given prestate
tx := new(types.Transaction)
- if err := rlp.DecodeBytes(common.FromHex(test.Input), tx); err != nil {
+ if err := tx.UnmarshalBinary(common.FromHex(test.Input)); err != nil {
return fmt.Errorf("failed to parse testcase input: %v", err)
}
signer := types.MakeSigner(test.Genesis.Config, new(big.Int).SetUint64(uint64(test.Context.Number)), uint64(test.Context.Time))
diff --git go-ethereum/eth/tracers/internal/tracetest/prestate_test.go op-geth/eth/tracers/internal/tracetest/prestate_test.go
index 8a60123dc2c656f9b39d29f55835648c2f3c65aa..9693eac4864479f78eb228b235cc3268f84b88b0 100644
--- go-ethereum/eth/tracers/internal/tracetest/prestate_test.go
+++ op-geth/eth/tracers/internal/tracetest/prestate_test.go
@@ -24,13 +24,13 @@ "path/filepath"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
- "github.com/ethereum/go-ethereum/tests"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/tests"
)
// prestateTrace is the result of a prestateTrace run.
diff --git go-ethereum/eth/tracers/js/tracer_test.go op-geth/eth/tracers/js/tracer_test.go
index b7f2693770be85838ac126bfb53533d1c41ac0f2..09f9e38a5c71b1e3abda6b31048e2d8f271acdc3 100644
--- go-ethereum/eth/tracers/js/tracer_test.go
+++ op-geth/eth/tracers/js/tracer_test.go
@@ -24,12 +24,12 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/params"
)
type account struct{}
diff --git go-ethereum/eth/tracers/logger/logger_test.go op-geth/eth/tracers/logger/logger_test.go
index 1d8eb320f6000d67030c5efefbb7c7fe3e4b55b6..0ab644a00c8a900cf2b37320d80b027e60596bd7 100644
--- go-ethereum/eth/tracers/logger/logger_test.go
+++ op-geth/eth/tracers/logger/logger_test.go
@@ -22,11 +22,11 @@ "errors"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/params"
)
type dummyContractRef struct {
@@ -77,7 +77,7 @@ }
}
// Tests that blank fields don't appear in logs when JSON marshalled, to reduce
-// logs bloat and confusion. See https://github.com/ethereum/go-ethereum/issues/24487
+// logs bloat and confusion. See https://github.com/tenderly/op-geth/issues/24487
func TestStructLogMarshalingOmitEmpty(t *testing.T) {
tests := []struct {
name string
diff --git go-ethereum/eth/tracers/tracers_test.go op-geth/eth/tracers/tracers_test.go
index 6ac266e06d614d6c9de2fdbd0697479e1b607915..4f31fa92bf0a198df166ec44f476b3a86b50b7dd 100644
--- go-ethereum/eth/tracers/tracers_test.go
+++ op-geth/eth/tracers/tracers_test.go
@@ -20,15 +20,15 @@ import (
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/tracers/logger"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/tests"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/tracers/logger"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/tests"
)
func BenchmarkTransactionTrace(b *testing.B) {
diff --git go-ethereum/ethclient/gethclient/gethclient_test.go op-geth/ethclient/gethclient/gethclient_test.go
index 158886475eda46b8ecf03f576e4d58da891bdc4a..c909170d4bbf17027a4f0639517726b90a526ab4 100644
--- go-ethereum/ethclient/gethclient/gethclient_test.go
+++ op-geth/ethclient/gethclient/gethclient_test.go
@@ -23,19 +23,19 @@ "encoding/json"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/eth/filters"
- "github.com/ethereum/go-ethereum/ethclient"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/eth/filters"
+ "github.com/tenderly/op-geth/ethclient"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
var (
diff --git go-ethereum/ethclient/simulated/backend_test.go op-geth/ethclient/simulated/backend_test.go
index a8fd7913c334101fb64194666727501eac7346ca..cd49bc74ab265c69dd511c73dff790c5cff5c492 100644
--- go-ethereum/ethclient/simulated/backend_test.go
+++ op-geth/ethclient/simulated/backend_test.go
@@ -24,11 +24,11 @@ "math/rand"
"testing"
"time"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
)
var _ bind.ContractBackend = (Client)(nil)
diff --git go-ethereum/ethclient/simulated/options_test.go op-geth/ethclient/simulated/options_test.go
index 9ff2be5ff93c3652b4f9abbef35d0b79085138ff..8356c7de4cccaa99efd644cb4fca331e7eea182a 100644
--- go-ethereum/ethclient/simulated/options_test.go
+++ op-geth/ethclient/simulated/options_test.go
@@ -22,10 +22,10 @@ "math/big"
"strings"
"testing"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
// Tests that the simulator starts with the initial gas limit in the genesis block,
diff --git go-ethereum/ethdb/leveldb/leveldb_test.go op-geth/ethdb/leveldb/leveldb_test.go
index d8c63860161ff5fe85eb732b34d784d67f61a2d9..bf0c9f7901c549c8a6bf87736129a8fa04d89034 100644
--- go-ethereum/ethdb/leveldb/leveldb_test.go
+++ op-geth/ethdb/leveldb/leveldb_test.go
@@ -19,10 +19,10 @@
import (
"testing"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/ethdb/dbtest"
"github.com/syndtr/goleveldb/leveldb"
"github.com/syndtr/goleveldb/leveldb/storage"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/ethdb/dbtest"
)
func TestLevelDB(t *testing.T) {
diff --git go-ethereum/ethdb/memorydb/memorydb_test.go op-geth/ethdb/memorydb/memorydb_test.go
index 51499c3b1f0e158548b2370b8b24572d9e28cc4c..32f411dff9aa05b0c9ebb0dcffa553d869265cc8 100644
--- go-ethereum/ethdb/memorydb/memorydb_test.go
+++ op-geth/ethdb/memorydb/memorydb_test.go
@@ -20,8 +20,8 @@ import (
"encoding/binary"
"testing"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/ethdb/dbtest"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/ethdb/dbtest"
)
func TestMemoryDB(t *testing.T) {
diff --git go-ethereum/ethdb/pebble/pebble_test.go op-geth/ethdb/pebble/pebble_test.go
index 1d5611f211e3649ee488a3fb94a2a073179a15c4..9471ad83e536eab2e3aed954e7df07b075bf4e34 100644
--- go-ethereum/ethdb/pebble/pebble_test.go
+++ op-geth/ethdb/pebble/pebble_test.go
@@ -21,8 +21,8 @@ "testing"
"github.com/cockroachdb/pebble"
"github.com/cockroachdb/pebble/vfs"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/ethdb/dbtest"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/ethdb/dbtest"
)
func TestPebbleDB(t *testing.T) {
diff --git go-ethereum/event/example_feed_test.go op-geth/event/example_feed_test.go
index 9b5ad50df546355c216872ee076116c3da88290b..27475ca0577b53abb1c0c4e2ea0ce6dfe0720689 100644
--- go-ethereum/event/example_feed_test.go
+++ op-geth/event/example_feed_test.go
@@ -19,7 +19,7 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/event"
+ "github.com/tenderly/op-geth/event"
)
func ExampleFeed_acknowledgedEvents() {
diff --git go-ethereum/event/example_scope_test.go op-geth/event/example_scope_test.go
index 825a8deeacba78ac16b8259577a5ddc9654c8f0b..8bf2d3494920b3d02db0dc30f00703069f7c7719 100644
--- go-ethereum/event/example_scope_test.go
+++ op-geth/event/example_scope_test.go
@@ -20,7 +20,7 @@ import (
"fmt"
"sync"
- "github.com/ethereum/go-ethereum/event"
+ "github.com/tenderly/op-geth/event"
)
// This example demonstrates how SubscriptionScope can be used to control the lifetime of
diff --git go-ethereum/event/example_subscription_test.go op-geth/event/example_subscription_test.go
index 5c76b55d98e8a193d27ff1b758a345b88be09d8a..2b3dbc303bbdc37c51eb4b853169672b260feeea 100644
--- go-ethereum/event/example_subscription_test.go
+++ op-geth/event/example_subscription_test.go
@@ -19,7 +19,7 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/event"
+ "github.com/tenderly/op-geth/event"
)
func ExampleNewSubscription() {
diff --git go-ethereum/graphql/graphql_test.go op-geth/graphql/graphql_test.go
index 1dda102058229ce52cc81346ffb7e7ea13687071..056fd477e107c82ce8a46fae00e62217ef3a7986 100644
--- go-ethereum/graphql/graphql_test.go
+++ op-geth/graphql/graphql_test.go
@@ -27,19 +27,19 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/eth/filters"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/eth/filters"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/params"
"github.com/stretchr/testify/assert"
)
diff --git go-ethereum/internal/era/e2store/e2store_test.go op-geth/internal/era/e2store/e2store_test.go
index febcffe4cf2cc4947ebe0407d5b102e51a962419..e716f5b8d8005c205b28ec018f5029df0cb05bfc 100644
--- go-ethereum/internal/era/e2store/e2store_test.go
+++ op-geth/internal/era/e2store/e2store_test.go
@@ -22,7 +22,7 @@ "fmt"
"io"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
func TestEncode(t *testing.T) {
diff --git go-ethereum/internal/era/era_test.go op-geth/internal/era/era_test.go
index ee5d9e82a099ecc8bbb2f6afe1b3d06415dbc6e5..d8b6e12fd52dde606e67fcdfe4f6417e7ad3b6f4 100644
--- go-ethereum/internal/era/era_test.go
+++ op-geth/internal/era/era_test.go
@@ -23,7 +23,7 @@ "math/big"
"os"
"testing"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
type testchain struct {
diff --git go-ethereum/internal/ethapi/api_test.go op-geth/internal/ethapi/api_test.go
index a6f7405eb3637aa180406ffdac374e62c0b12c28..afa72b76dc108e06a4ce599b2fa660b3573d2b18 100644
--- go-ethereum/internal/ethapi/api_test.go
+++ op-geth/internal/ethapi/api_test.go
@@ -31,32 +31,191 @@ "reflect"
"testing"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/bloombits"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/internal/blocktest"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/holiman/uint256"
"github.com/stretchr/testify/require"
"golang.org/x/exp/slices"
+
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/bloombits"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/internal/blocktest"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
+func TestNewRPCTransactionDepositTx(t *testing.T) {
+ tx := types.NewTx(&types.DepositTx{
+ SourceHash: common.HexToHash("0x1234"),
+ IsSystemTransaction: true,
+ Mint: big.NewInt(34),
+ })
+ nonce := uint64(7)
+ receipt := &types.Receipt{
+ DepositNonce: &nonce,
+ }
+ got := newRPCTransaction(tx, common.Hash{}, uint64(12), uint64(1234), uint64(1), big.NewInt(0), ¶ms.ChainConfig{}, receipt)
+ // Should provide zero values for unused fields that are required in other transactions
+ require.Equal(t, got.GasPrice, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().GasPrice = %v, want 0x0", got.GasPrice)
+ require.Equal(t, got.V, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().V = %v, want 0x0", got.V)
+ require.Equal(t, got.R, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().R = %v, want 0x0", got.R)
+ require.Equal(t, got.S, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().S = %v, want 0x0", got.S)
+
+ // Should include deposit tx specific fields
+ require.Equal(t, *got.SourceHash, tx.SourceHash(), "newRPCTransaction().SourceHash = %v, want %v", got.SourceHash, tx.SourceHash())
+ require.Equal(t, *got.IsSystemTx, tx.IsSystemTx(), "newRPCTransaction().IsSystemTx = %v, want %v", got.IsSystemTx, tx.IsSystemTx())
+ require.Equal(t, got.Mint, (*hexutil.Big)(tx.Mint()), "newRPCTransaction().Mint = %v, want %v", got.Mint, tx.Mint())
+ require.Equal(t, got.Nonce, (hexutil.Uint64)(nonce), "newRPCTransaction().Nonce = %v, want %v", got.Nonce, nonce)
+}
+
+func TestRPCTransactionDepositTxWithVersion(t *testing.T) {
+ tx := types.NewTx(&types.DepositTx{
+ SourceHash: common.HexToHash("0x1234"),
+ IsSystemTransaction: true,
+ Mint: big.NewInt(34),
+ })
+ nonce := uint64(7)
+ version := types.CanyonDepositReceiptVersion
+ receipt := &types.Receipt{
+ DepositNonce: &nonce,
+ DepositReceiptVersion: &version,
+ }
+ got := newRPCTransaction(tx, common.Hash{}, uint64(12), uint64(1234), uint64(1), big.NewInt(0), ¶ms.ChainConfig{}, receipt)
+ // Should provide zero values for unused fields that are required in other transactions
+ require.Equal(t, got.GasPrice, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().GasPrice = %v, want 0x0", got.GasPrice)
+ require.Equal(t, got.V, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().V = %v, want 0x0", got.V)
+ require.Equal(t, got.R, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().R = %v, want 0x0", got.R)
+ require.Equal(t, got.S, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().S = %v, want 0x0", got.S)
+
+ // Should include versioned deposit tx specific fields
+ require.Equal(t, *got.SourceHash, tx.SourceHash(), "newRPCTransaction().SourceHash = %v, want %v", got.SourceHash, tx.SourceHash())
+ require.Equal(t, *got.IsSystemTx, tx.IsSystemTx(), "newRPCTransaction().IsSystemTx = %v, want %v", got.IsSystemTx, tx.IsSystemTx())
+ require.Equal(t, got.Mint, (*hexutil.Big)(tx.Mint()), "newRPCTransaction().Mint = %v, want %v", got.Mint, tx.Mint())
+ require.Equal(t, got.Nonce, (hexutil.Uint64)(nonce), "newRPCTransaction().Nonce = %v, want %v", got.Nonce, nonce)
+ require.Equal(t, *got.DepositReceiptVersion, (hexutil.Uint64(version)), "newRPCTransaction().DepositReceiptVersion = %v, want %v", *got.DepositReceiptVersion, version)
+
+ // Make sure json marshal/unmarshal of the rpc tx preserves the receipt version
+ b, err := json.Marshal(got)
+ require.NoError(t, err, "marshalling failed: %w", err)
+ parsed := make(map[string]interface{})
+ err = json.Unmarshal(b, &parsed)
+ require.NoError(t, err, "unmarshalling failed: %w", err)
+ require.Equal(t, "0x1", parsed["depositReceiptVersion"])
+}
+
+func TestNewRPCTransactionOmitIsSystemTxFalse(t *testing.T) {
+ tx := types.NewTx(&types.DepositTx{
+ IsSystemTransaction: false,
+ })
+ got := newRPCTransaction(tx, common.Hash{}, uint64(12), uint64(1234), uint64(1), big.NewInt(0), ¶ms.ChainConfig{}, nil)
+
+ require.Nil(t, got.IsSystemTx, "should omit IsSystemTx when false")
+}
+
+func TestUnmarshalRpcDepositTx(t *testing.T) {
+ version := hexutil.Uint64(types.CanyonDepositReceiptVersion)
+ tests := []struct {
+ name string
+ modifier func(tx *RPCTransaction)
+ valid bool
+ }{
+ {
+ name: "Unmodified",
+ modifier: func(tx *RPCTransaction) {},
+ valid: true,
+ },
+ {
+ name: "Zero Values",
+ modifier: func(tx *RPCTransaction) {
+ tx.V = (*hexutil.Big)(common.Big0)
+ tx.R = (*hexutil.Big)(common.Big0)
+ tx.S = (*hexutil.Big)(common.Big0)
+ tx.GasPrice = (*hexutil.Big)(common.Big0)
+ },
+ valid: true,
+ },
+ {
+ name: "Nil Values",
+ modifier: func(tx *RPCTransaction) {
+ tx.V = nil
+ tx.R = nil
+ tx.S = nil
+ tx.GasPrice = nil
+ },
+ valid: true,
+ },
+ {
+ name: "Non-Zero GasPrice",
+ modifier: func(tx *RPCTransaction) {
+ tx.GasPrice = (*hexutil.Big)(big.NewInt(43))
+ },
+ valid: false,
+ },
+ {
+ name: "Non-Zero V",
+ modifier: func(tx *RPCTransaction) {
+ tx.V = (*hexutil.Big)(big.NewInt(43))
+ },
+ valid: false,
+ },
+ {
+ name: "Non-Zero R",
+ modifier: func(tx *RPCTransaction) {
+ tx.R = (*hexutil.Big)(big.NewInt(43))
+ },
+ valid: false,
+ },
+ {
+ name: "Non-Zero S",
+ modifier: func(tx *RPCTransaction) {
+ tx.S = (*hexutil.Big)(big.NewInt(43))
+ },
+ valid: false,
+ },
+ {
+ name: "Non-nil deposit receipt version",
+ modifier: func(tx *RPCTransaction) {
+ tx.DepositReceiptVersion = &version
+ },
+ valid: true,
+ },
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ tx := types.NewTx(&types.DepositTx{
+ SourceHash: common.HexToHash("0x1234"),
+ IsSystemTransaction: true,
+ Mint: big.NewInt(34),
+ })
+ rpcTx := newRPCTransaction(tx, common.Hash{}, uint64(12), uint64(1234), uint64(1), big.NewInt(0), ¶ms.ChainConfig{}, nil)
+ test.modifier(rpcTx)
+ json, err := json.Marshal(rpcTx)
+ require.NoError(t, err, "marshalling failed: %w", err)
+ parsed := &types.Transaction{}
+ err = parsed.UnmarshalJSON(json)
+ if test.valid {
+ require.NoError(t, err, "unmarshal failed: %w", err)
+ } else {
+ require.Error(t, err, "unmarshal should have failed but did not")
+ }
+ })
+ }
+}
+
func testTransactionMarshal(t *testing.T, tests []txData, config *params.ChainConfig) {
t.Parallel()
var (
@@ -80,7 +239,7 @@ t.Fatalf("test %d: stx changed, want %x have %x", i, want, have)
}
// rpcTransaction
- rpcTx := newRPCTransaction(tx, common.Hash{}, 0, 0, 0, nil, config)
+ rpcTx := newRPCTransaction(tx, common.Hash{}, 0, 0, 0, nil, config, nil)
if data, err := json.Marshal(rpcTx); err != nil {
t.Fatalf("test %d: marshalling failed; %v", i, err)
} else if err = tx2.UnmarshalJSON(data); err != nil {
@@ -567,7 +726,7 @@ if vmConfig == nil {
vmConfig = b.chain.GetVMConfig()
}
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(header, b.chain, nil)
+ context := core.NewEVMBlockContext(header, b.chain, nil, b.ChainConfig(), state)
if blockContext != nil {
context = *blockContext
}
@@ -622,6 +781,12 @@ func (b testBackend) BloomStatus() (uint64, uint64) { panic("implement me") }
func (b testBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession) {
panic("implement me")
}
+func (b testBackend) HistoricalRPCService() *rpc.Client {
+ panic("implement me")
+}
+func (b testBackend) Genesis() *types.Block {
+ panic("implement me")
+}
func TestEstimateGas(t *testing.T) {
t.Parallel()
@@ -843,7 +1008,7 @@ From: &accounts[0].addr,
To: &accounts[1].addr,
Value: (*hexutil.Big)(big.NewInt(1000)),
},
- expectErr: errors.New("header not found"),
+ expectErr: ethereum.NotFound,
},
// transfer on the latest block
{
@@ -1466,7 +1631,7 @@ "to": "0x0000000000000000000000000000000000000011",
"transactionIndex": "0x1",
"value": "0x6f",
"type": "0x0",
- "chainId": "0x7fffffffffffffee",
+ "chainId": "0x1",
"v": "0x0",
"r": "0x0",
"s": "0x0"
@@ -1504,7 +1669,7 @@ "to": "0x0000000000000000000000000000000000000011",
"transactionIndex": "0x3",
"value": "0x6f",
"type": "0x0",
- "chainId": "0x7fffffffffffffee",
+ "chainId": "0x1",
"v": "0x0",
"r": "0x0",
"s": "0x0"
@@ -1517,7 +1682,11 @@ },
}
for i, tc := range testSuite {
- resp := RPCMarshalBlock(block, tc.inclTx, tc.fullTx, params.MainnetChainConfig)
+ resp, err := RPCMarshalBlock(context.Background(), block, tc.inclTx, tc.fullTx, params.MainnetChainConfig, testBackend{})
+ if err != nil {
+ t.Errorf("test %d: got error %v", i, err)
+ continue
+ }
out, err := json.Marshal(resp)
if err != nil {
t.Errorf("test %d: json marshal error: %v", i, err)
diff --git go-ethereum/internal/guide/guide_test.go op-geth/internal/guide/guide_test.go
index f682daac91b029e36c572f0920967b7fca49f31f..a58fc8f6a7dafcd5bcb660a510521aa3cf303b0a 100644
--- go-ethereum/internal/guide/guide_test.go
+++ op-geth/internal/guide/guide_test.go
@@ -28,9 +28,9 @@ "path/filepath"
"testing"
"time"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
)
// Tests that the account management snippets work correctly.
diff --git go-ethereum/metrics/influxdb/influxdb_test.go op-geth/metrics/influxdb/influxdb_test.go
index c6f2eeac62771186603424165133a5dc884a8f8d..21e539f7affaa0b2715a56d8d5e9b1f5869872e7 100644
--- go-ethereum/metrics/influxdb/influxdb_test.go
+++ op-geth/metrics/influxdb/influxdb_test.go
@@ -26,9 +26,9 @@ "os"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/metrics/internal"
influxdb2 "github.com/influxdata/influxdb-client-go/v2"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/metrics/internal"
)
func TestMain(m *testing.M) {
diff --git go-ethereum/metrics/internal/sampledata_test.go op-geth/metrics/internal/sampledata_test.go
index 00132994064e36f4ca88f38bb4ad197b1facc37f..85476923b172c0b5f965d2f6a110a62d79287716 100644
--- go-ethereum/metrics/internal/sampledata_test.go
+++ op-geth/metrics/internal/sampledata_test.go
@@ -8,7 +8,7 @@ metrics2 "runtime/metrics"
"testing"
"time"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/metrics"
)
func TestCollectRuntimeMetrics(t *testing.T) {
diff --git go-ethereum/metrics/prometheus/collector_test.go op-geth/metrics/prometheus/collector_test.go
index ea17aac4585fd8688f9d2734435265ab7dc20ece..109d79fc31b3fa945a73961e3670b863910650f8 100644
--- go-ethereum/metrics/prometheus/collector_test.go
+++ op-geth/metrics/prometheus/collector_test.go
@@ -22,8 +22,8 @@ "os"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/metrics/internal"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/metrics/internal"
)
func TestMain(m *testing.M) {
diff --git go-ethereum/node/api_test.go op-geth/node/api_test.go
index 8761c4883ef8a6bdc76509405b2242d17a9254ad..25a76fa80d5b61aefcce2f37f1775c9aa1c21ee0 100644
--- go-ethereum/node/api_test.go
+++ op-geth/node/api_test.go
@@ -25,8 +25,8 @@ "net/url"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/stretchr/testify/assert"
+ "github.com/tenderly/op-geth/rpc"
)
// This test uses the admin_startRPC and admin_startWS APIs,
diff --git go-ethereum/node/config_test.go op-geth/node/config_test.go
index e8af8ddcd87b49d95e14a5ede59ede6f274a4df0..6fcb5c9d95c8ffc0fd4e324b5b91ae74e4d43be0 100644
--- go-ethereum/node/config_test.go
+++ op-geth/node/config_test.go
@@ -23,8 +23,8 @@ "path/filepath"
"runtime"
"testing"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p"
)
// Tests that datadirs can be successfully created, be them manually configured
diff --git go-ethereum/node/node_auth_test.go op-geth/node/node_auth_test.go
index 597cd8531f790100180fc3e4263095e90b47ab11..52762ae49c002ae05cc0ec1e4810b9b3c63ba5e5 100644
--- go-ethereum/node/node_auth_test.go
+++ op-geth/node/node_auth_test.go
@@ -26,9 +26,9 @@ "path"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/golang-jwt/jwt/v4"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/rpc"
)
type helloRPC string
diff --git go-ethereum/node/node_example_test.go op-geth/node/node_example_test.go
index e45ee49a25a00b38dc6a6646455d42d41733ae39..2353ec8782ac5a4795f87178d8cf04f5e5efb68a 100644
--- go-ethereum/node/node_example_test.go
+++ op-geth/node/node_example_test.go
@@ -20,7 +20,7 @@ import (
"fmt"
"log"
- "github.com/ethereum/go-ethereum/node"
+ "github.com/tenderly/op-geth/node"
)
// SampleLifecycle is a trivial network service that can be attached to a node for
diff --git go-ethereum/node/node_test.go op-geth/node/node_test.go
index 04810a815bf67d37f6de23de663fd74c18e1bdac..575671953ea709138f34e2309ac86a974b4d019e 100644
--- go-ethereum/node/node_test.go
+++ op-geth/node/node_test.go
@@ -26,10 +26,10 @@ "reflect"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/rpc"
"github.com/stretchr/testify/assert"
)
diff --git go-ethereum/node/rpcstack_test.go op-geth/node/rpcstack_test.go
index e41cc51ad318d49528403d1e037ce96ac1957574..259af5e44cb6b4077152bc8a99baeb91098019fc 100644
--- go-ethereum/node/rpcstack_test.go
+++ op-geth/node/rpcstack_test.go
@@ -28,12 +28,12 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/internal/testlog"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/golang-jwt/jwt/v4"
"github.com/gorilla/websocket"
"github.com/stretchr/testify/assert"
+ "github.com/tenderly/op-geth/internal/testlog"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rpc"
)
const testMethod = "rpc_modules"
diff --git go-ethereum/node/utils_test.go op-geth/node/utils_test.go
index 681f3a8b285c4930f6005b98ea81815e0e67fb56..b9612daaf50a3a45fa49ddc489981cf006febaf7 100644
--- go-ethereum/node/utils_test.go
+++ op-geth/node/utils_test.go
@@ -20,8 +20,8 @@
package node
import (
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/rpc"
)
// NoopLifecycle is a trivial implementation of the Service interface.
diff --git go-ethereum/p2p/dial_test.go op-geth/p2p/dial_test.go
index 13908f11eab3f09c7ec41c9f344bcc6c0b3636e3..c2d103e39eddce85a3bbb5f88965d5578e6a49e5 100644
--- go-ethereum/p2p/dial_test.go
+++ op-geth/p2p/dial_test.go
@@ -27,11 +27,11 @@ "sync"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/internal/testlog"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/internal/testlog"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/netutil"
)
// This test checks that dynamic dials are launched from discovery results.
diff --git go-ethereum/p2p/discover/table_test.go op-geth/p2p/discover/table_test.go
index 3ba342225133e55eb2594068e9545f05b4822db7..93e3c2d901cceb1f30c8593648056468deb3d263 100644
--- go-ethereum/p2p/discover/table_test.go
+++ op-geth/p2p/discover/table_test.go
@@ -27,10 +27,10 @@ "testing"
"testing/quick"
"time"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/p2p/netutil"
)
func TestTable_pingReplace(t *testing.T) {
diff --git go-ethereum/p2p/discover/table_util_test.go op-geth/p2p/discover/table_util_test.go
index d6309dfd6c69e5453d7827cb782090258764aebc..faf37e91ccd96139193c34dfcbd03dd7b9247c70 100644
--- go-ethereum/p2p/discover/table_util_test.go
+++ op-geth/p2p/discover/table_util_test.go
@@ -26,9 +26,9 @@ "math/rand"
"net"
"sync"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/p2p/discover/v4_lookup_test.go op-geth/p2p/discover/v4_lookup_test.go
index 8867a5a8ac7528880edc53dfc61e85e39494587d..2df9c23ecc9ceb01122389b2e54881cb7de63e45 100644
--- go-ethereum/p2p/discover/v4_lookup_test.go
+++ op-geth/p2p/discover/v4_lookup_test.go
@@ -22,10 +22,10 @@ "fmt"
"net"
"testing"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/discover/v4wire"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/discover/v4wire"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/p2p/discover/v4_udp_test.go op-geth/p2p/discover/v4_udp_test.go
index 361e37962648a4f87fe1213452e04a4055e0e21c..49753d3c07a86b27d14dc4ee452e3cac88a793a6 100644
--- go-ethereum/p2p/discover/v4_udp_test.go
+++ op-geth/p2p/discover/v4_udp_test.go
@@ -31,11 +31,11 @@ "sync"
"testing"
"time"
- "github.com/ethereum/go-ethereum/internal/testlog"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/discover/v4wire"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/internal/testlog"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/discover/v4wire"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
)
// shared test variables
diff --git go-ethereum/p2p/discover/v4wire/v4wire_test.go op-geth/p2p/discover/v4wire/v4wire_test.go
index 38820f3b48fadac796c2f07262b8e12c7b718fc1..5c85d59d532a8269431e8b62851d32c25a921f9b 100644
--- go-ethereum/p2p/discover/v4wire/v4wire_test.go
+++ op-geth/p2p/discover/v4wire/v4wire_test.go
@@ -23,8 +23,8 @@ "reflect"
"testing"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
)
// EIP-8 test vectors.
diff --git go-ethereum/p2p/discover/v5_udp_test.go op-geth/p2p/discover/v5_udp_test.go
index eaa969ea8b697d5f5475b69f99f363e0cb2b694f..64f38c7f843bbb33cccdbdc464c2dd66eaa7f419 100644
--- go-ethereum/p2p/discover/v5_udp_test.go
+++ op-geth/p2p/discover/v5_udp_test.go
@@ -27,13 +27,13 @@ "reflect"
"testing"
"time"
- "github.com/ethereum/go-ethereum/internal/testlog"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/discover/v5wire"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/stretchr/testify/require"
+ "github.com/tenderly/op-geth/internal/testlog"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/discover/v5wire"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/p2p/discover/v5wire/crypto_test.go op-geth/p2p/discover/v5wire/crypto_test.go
index 72169b43141a5841bfde932dd2fc882b5bbd2b09..406c0f039a295c2580f7bb403177f9a02aabfc91 100644
--- go-ethereum/p2p/discover/v5wire/crypto_test.go
+++ op-geth/p2p/discover/v5wire/crypto_test.go
@@ -25,9 +25,9 @@ "reflect"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enode"
)
func TestVector_ECDH(t *testing.T) {
diff --git go-ethereum/p2p/discover/v5wire/encoding_test.go op-geth/p2p/discover/v5wire/encoding_test.go
index a5387311a5d02ba4582b92bc5f8001db14b9db54..51eff0a3ded520fd798a367c5675761fd423a06b 100644
--- go-ethereum/p2p/discover/v5wire/encoding_test.go
+++ op-geth/p2p/discover/v5wire/encoding_test.go
@@ -30,10 +30,10 @@ "strings"
"testing"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// To regenerate discv5 test vectors, run
diff --git go-ethereum/p2p/dnsdisc/client_test.go op-geth/p2p/dnsdisc/client_test.go
index abc35ddbd3d341ed9f5ffe3bfe6d89cb15b9ff96..cf3549ec5358243f5af841d4a3dbba39d0a970bc 100644
--- go-ethereum/p2p/dnsdisc/client_test.go
+++ op-geth/p2p/dnsdisc/client_test.go
@@ -25,13 +25,13 @@ "testing"
"time"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/testlog"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/testlog"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
)
var signingKeyForTesting, _ = crypto.ToECDSA(hexutil.MustDecode("0xdc599867fc513f8f5e2c2c9c489cde5e71362d1d9ec6e693e0de063236ed1240"))
diff --git go-ethereum/p2p/dnsdisc/tree_test.go op-geth/p2p/dnsdisc/tree_test.go
index 9ed17aa4b3e6ad3f5bc82c786df877465c998554..03df51a2155fe8e2b64f55dc88514703b78c23e6 100644
--- go-ethereum/p2p/dnsdisc/tree_test.go
+++ op-geth/p2p/dnsdisc/tree_test.go
@@ -21,8 +21,8 @@ "reflect"
"testing"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/p2p/enode"
)
func TestParseRoot(t *testing.T) {
diff --git go-ethereum/p2p/enode/idscheme_test.go op-geth/p2p/enode/idscheme_test.go
index 0910e6e83f610ff860f6b92e7e5c1162df0d469d..ee18c6d819b45c9656b8fbea3f7dfd0bbb497f4d 100644
--- go-ethereum/p2p/enode/idscheme_test.go
+++ op-geth/p2p/enode/idscheme_test.go
@@ -23,11 +23,11 @@ "encoding/hex"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
)
var (
diff --git go-ethereum/p2p/enode/iter_test.go op-geth/p2p/enode/iter_test.go
index b736ed450adf174ec0cea17ea2386f01450da7f7..2d286f9446982c31b40f37f5325141ba50354157 100644
--- go-ethereum/p2p/enode/iter_test.go
+++ op-geth/p2p/enode/iter_test.go
@@ -23,7 +23,7 @@ "sync/atomic"
"testing"
"time"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/p2p/enr"
)
func TestReadNodes(t *testing.T) {
diff --git go-ethereum/p2p/enode/localnode_test.go op-geth/p2p/enode/localnode_test.go
index 7f97ad392f27c6db4230c3940acc389a981d640e..1a257097f9d9e902c6dc3320d230c249b2536fe2 100644
--- go-ethereum/p2p/enode/localnode_test.go
+++ op-geth/p2p/enode/localnode_test.go
@@ -21,9 +21,9 @@ "crypto/rand"
"net"
"testing"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enr"
"github.com/stretchr/testify/assert"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enr"
)
func newLocalNodeForTesting() (*LocalNode, *DB) {
diff --git go-ethereum/p2p/enode/node_test.go op-geth/p2p/enode/node_test.go
index d15859c477a585f96a08a9e7bfd06b16eb016cbf..b91216e0b418031861f20d36ae03c669cedfea65 100644
--- go-ethereum/p2p/enode/node_test.go
+++ op-geth/p2p/enode/node_test.go
@@ -24,9 +24,9 @@ "math/big"
"testing"
"testing/quick"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/stretchr/testify/assert"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
)
var pyRecord, _ = hex.DecodeString("f884b8407098ad865b00a582051940cb9cf36836572411a47278783077011599ed5cd16b76f2635f4e234738f30813a89eb9137e3e3df5266e3a1f11df72ecf1145ccb9c01826964827634826970847f00000189736563703235366b31a103ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31388375647082765f")
diff --git go-ethereum/p2p/enode/urlv4_test.go op-geth/p2p/enode/urlv4_test.go
index 33de96cc57f1bbae7d61dcef5a703349d21a980d..f0d39cc7c5063e91b83f52894db795160fd68242 100644
--- go-ethereum/p2p/enode/urlv4_test.go
+++ op-geth/p2p/enode/urlv4_test.go
@@ -24,8 +24,8 @@ "reflect"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enr"
)
func init() {
diff --git go-ethereum/p2p/enr/enr_test.go op-geth/p2p/enr/enr_test.go
index b85ee209d591cb8fbcc93c109c88e32ef96a8855..e76fa232eacb816aba514760f6dea22a17a842c7 100644
--- go-ethereum/p2p/enr/enr_test.go
+++ op-geth/p2p/enr/enr_test.go
@@ -24,9 +24,9 @@ "math/rand"
"testing"
"time"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
+ "github.com/tenderly/op-geth/rlp"
)
var rnd = rand.New(rand.NewSource(time.Now().UnixNano()))
diff --git go-ethereum/p2p/nat/natupnp_test.go op-geth/p2p/nat/natupnp_test.go
index 9072451d50c72601cf425092b0d8f83a68f65d00..ca306937186fe6c4657276a977813a58cf8cc170 100644
--- go-ethereum/p2p/nat/natupnp_test.go
+++ op-geth/p2p/nat/natupnp_test.go
@@ -166,7 +166,7 @@ if discovered == nil {
if os.Getenv("CI") != "" {
t.Fatalf("not discovered")
} else {
- t.Skipf("UPnP not discovered (known issue, see https://github.com/ethereum/go-ethereum/issues/21476)")
+ t.Skipf("UPnP not discovered (known issue, see https://github.com/tenderly/op-geth/issues/21476)")
}
}
upnp, _ := discovered.(*upnp)
diff --git go-ethereum/p2p/netutil/iptrack_test.go op-geth/p2p/netutil/iptrack_test.go
index ee3bba861e253a8fad4cfd0659ca34712803497d..e53eeeab058613dcfb0afe71d7274b4723e37242 100644
--- go-ethereum/p2p/netutil/iptrack_test.go
+++ op-geth/p2p/netutil/iptrack_test.go
@@ -22,7 +22,7 @@ "fmt"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
+ "github.com/tenderly/op-geth/common/mclock"
)
const (
diff --git go-ethereum/p2p/nodestate/nodestate_test.go op-geth/p2p/nodestate/nodestate_test.go
index d06ad755e22e86d842651f2f48f9eb8d396d0899..36dc4fa3845179f7b7ac7be379fc853470f6b139 100644
--- go-ethereum/p2p/nodestate/nodestate_test.go
+++ op-geth/p2p/nodestate/nodestate_test.go
@@ -23,11 +23,11 @@ "reflect"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
)
func testSetup(flagPersist []bool, fieldType []reflect.Type) (*Setup, []Flags, []Field) {
diff --git go-ethereum/p2p/peer_test.go op-geth/p2p/peer_test.go
index 4308bbd2eb4b7251f8da9e09f0161588fb1aa147..3cc645b5cc42215b492ab601994ce5dc079bd94e 100644
--- go-ethereum/p2p/peer_test.go
+++ op-geth/p2p/peer_test.go
@@ -28,9 +28,9 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
)
var discard = Protocol{
diff --git go-ethereum/p2p/rlpx/buffer_test.go op-geth/p2p/rlpx/buffer_test.go
index 9fee4172bd09b5e309be549ee00926541821920b..5ab5275b6e9c4eccb69fc6554ec0331263a0b6a6 100644
--- go-ethereum/p2p/rlpx/buffer_test.go
+++ op-geth/p2p/rlpx/buffer_test.go
@@ -20,8 +20,8 @@ import (
"bytes"
"testing"
- "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/stretchr/testify/assert"
+ "github.com/tenderly/op-geth/common/hexutil"
)
func TestReadBufferReset(t *testing.T) {
diff --git go-ethereum/p2p/rlpx/rlpx_test.go op-geth/p2p/rlpx/rlpx_test.go
index 136cb1b5bfcaeb52249177aa40dccedc60d0d271..df4ad0e50eb8c511354da23c3620b0e7a957f5bd 100644
--- go-ethereum/p2p/rlpx/rlpx_test.go
+++ op-geth/p2p/rlpx/rlpx_test.go
@@ -29,11 +29,11 @@ "strings"
"testing"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/crypto/ecies"
- "github.com/ethereum/go-ethereum/p2p/simulations/pipes"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/stretchr/testify/assert"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/crypto/ecies"
+ "github.com/tenderly/op-geth/p2p/simulations/pipes"
+ "github.com/tenderly/op-geth/rlp"
)
type message struct {
diff --git go-ethereum/p2p/server_nat_test.go op-geth/p2p/server_nat_test.go
index de935fcfc56df9a7557df8f9ad0ee1f2de103710..889eb36e26e93b7d049f80d27763d9118e29b3d1 100644
--- go-ethereum/p2p/server_nat_test.go
+++ op-geth/p2p/server_nat_test.go
@@ -22,9 +22,9 @@ "sync/atomic"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/internal/testlog"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/internal/testlog"
+ "github.com/tenderly/op-geth/log"
)
func TestServerPortMapping(t *testing.T) {
diff --git go-ethereum/p2p/server_test.go op-geth/p2p/server_test.go
index a0491e984a79982f06f628730cbbe13f24f9bb21..ff663934c952070fdad0db5b8706ba9dd1657a66 100644
--- go-ethereum/p2p/server_test.go
+++ op-geth/p2p/server_test.go
@@ -29,12 +29,12 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/testlog"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/p2p/rlpx"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/testlog"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/p2p/rlpx"
)
type testTransport struct {
diff --git go-ethereum/p2p/simulations/adapters/inproc_test.go op-geth/p2p/simulations/adapters/inproc_test.go
index 2a61508fe18b8d9b62e464fc8c801a4b7b19ecb0..d596428e28dfe33f397cdd52a3f6ac85347e42fe 100644
--- go-ethereum/p2p/simulations/adapters/inproc_test.go
+++ op-geth/p2p/simulations/adapters/inproc_test.go
@@ -23,7 +23,7 @@ "fmt"
"sync"
"testing"
- "github.com/ethereum/go-ethereum/p2p/simulations/pipes"
+ "github.com/tenderly/op-geth/p2p/simulations/pipes"
)
func TestTCPPipe(t *testing.T) {
diff --git go-ethereum/p2p/simulations/connect_test.go op-geth/p2p/simulations/connect_test.go
index 0154a18b030ffa58e5e542e752cbd0ffa603ff2f..b3565ab9b8ea4442c05c18e03b1b5ce0ef226842 100644
--- go-ethereum/p2p/simulations/connect_test.go
+++ op-geth/p2p/simulations/connect_test.go
@@ -19,9 +19,9 @@
import (
"testing"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/simulations/adapters"
)
func newTestNetwork(t *testing.T, nodeCount int) (*Network, []enode.ID) {
diff --git go-ethereum/p2p/simulations/http_test.go op-geth/p2p/simulations/http_test.go
index c53a49797bd399367b2bda07fdc68535f3d9bf3d..9ef69efa67a1dde56d4c19db4908b5e35da41ef2 100644
--- go-ethereum/p2p/simulations/http_test.go
+++ op-geth/p2p/simulations/http_test.go
@@ -29,14 +29,14 @@ "sync/atomic"
"testing"
"time"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/mattn/go-colorable"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/simulations/adapters"
+ "github.com/tenderly/op-geth/rpc"
"golang.org/x/exp/slog"
)
diff --git go-ethereum/p2p/simulations/mocker_test.go op-geth/p2p/simulations/mocker_test.go
index 0112ee5cfd6e55d4cd8e76ca40c5855d62630391..7807370b94fe923c2253db48e47a3c25988cc2ae 100644
--- go-ethereum/p2p/simulations/mocker_test.go
+++ op-geth/p2p/simulations/mocker_test.go
@@ -27,7 +27,7 @@ "sync"
"testing"
"time"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enode"
)
func TestMocker(t *testing.T) {
diff --git go-ethereum/p2p/simulations/network_test.go op-geth/p2p/simulations/network_test.go
index 4ed1e4e6c33bc34f350e9c6b420667500751240f..81ff2a2a9b737e47c9cbb9df3608116dcef03b98 100644
--- go-ethereum/p2p/simulations/network_test.go
+++ op-geth/p2p/simulations/network_test.go
@@ -27,10 +27,10 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/simulations/adapters"
)
// Tests that a created snapshot with a minimal service only contains the expected connections
diff --git go-ethereum/p2p/transport_test.go op-geth/p2p/transport_test.go
index 24e06c5a06bce7d5d949540162e65ca4d8a1e74b..35d2fc4799dae65f03dec3f2414f75d549b8b827 100644
--- go-ethereum/p2p/transport_test.go
+++ op-geth/p2p/transport_test.go
@@ -23,8 +23,8 @@ "sync"
"testing"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/simulations/pipes"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/simulations/pipes"
)
func TestProtocolHandshake(t *testing.T) {
diff --git go-ethereum/p2p/util_test.go op-geth/p2p/util_test.go
index cc0d2b215feecdee968803cfc72ec2f9dc1a083a..fc01392f8bdeaa58c18ee78656f205ecdc34e8a3 100644
--- go-ethereum/p2p/util_test.go
+++ op-geth/p2p/util_test.go
@@ -20,7 +20,7 @@ import (
"testing"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
+ "github.com/tenderly/op-geth/common/mclock"
)
func TestExpHeap(t *testing.T) {
diff --git go-ethereum/params/config_test.go op-geth/params/config_test.go
index bf8ce2fc5e247242615ff478a455785f9f07f88b..c62c03cf7daa32d8d54fef08eea00e347af2315e 100644
--- go-ethereum/params/config_test.go
+++ op-geth/params/config_test.go
@@ -22,7 +22,7 @@ "reflect"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common/math"
+ "github.com/tenderly/op-geth/common/math"
)
func TestCheckCompatible(t *testing.T) {
@@ -137,3 +137,23 @@ if r := c.Rules(big.NewInt(0), true, stamp); !r.IsShanghai {
t.Errorf("expected %v to be shanghai", stamp)
}
}
+
+func TestConfigRulesRegolith(t *testing.T) {
+ c := &ChainConfig{
+ RegolithTime: newUint64(500),
+ LondonBlock: new(big.Int),
+ Optimism: &OptimismConfig{},
+ }
+ var stamp uint64
+ if r := c.Rules(big.NewInt(0), true, stamp); r.IsOptimismRegolith {
+ t.Errorf("expected %v to not be regolith", stamp)
+ }
+ stamp = 500
+ if r := c.Rules(big.NewInt(0), true, stamp); !r.IsOptimismRegolith {
+ t.Errorf("expected %v to be regolith", stamp)
+ }
+ stamp = math.MaxInt64
+ if r := c.Rules(big.NewInt(0), true, stamp); !r.IsOptimismRegolith {
+ t.Errorf("expected %v to be regolith", stamp)
+ }
+}
diff --git go-ethereum/params/superchain_test.go op-geth/params/superchain_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..abb72bbd351f4c0a99ea8b78deac222a816a9ccc
--- /dev/null
+++ op-geth/params/superchain_test.go
@@ -0,0 +1,172 @@
+package params
+
+import (
+ "fmt"
+ "testing"
+)
+
+type HumanProtocolVersion struct {
+ VersionType uint8
+ Major, Minor, Patch uint32
+ Prerelease uint32
+ Build [8]byte
+}
+
+type ComparisonCase struct {
+ A, B HumanProtocolVersion
+ Cmp ProtocolVersionComparison
+}
+
+func TestProtocolVersion_Compare(t *testing.T) {
+ testCases := []ComparisonCase{
+ {
+ A: HumanProtocolVersion{0, 2, 1, 1, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 2, 2, 2, [8]byte{}},
+ Cmp: AheadMajor,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, 2, 1, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 1, 2, 2, [8]byte{}},
+ Cmp: AheadMinor,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, 1, 2, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 1, 1, 2, [8]byte{}},
+ Cmp: AheadPatch,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, 1, 1, 2, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 1, 1, 1, [8]byte{}},
+ Cmp: AheadPrerelease,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, 2, 3, 4, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 2, 3, 4, [8]byte{}},
+ Cmp: Matching,
+ },
+ {
+ A: HumanProtocolVersion{0, 3, 2, 1, 5, [8]byte{3}},
+ B: HumanProtocolVersion{1, 1, 2, 3, 3, [8]byte{6}},
+ Cmp: DiffVersionType,
+ },
+ {
+ A: HumanProtocolVersion{0, 3, 2, 1, 5, [8]byte{3}},
+ B: HumanProtocolVersion{0, 1, 2, 3, 3, [8]byte{6}},
+ Cmp: DiffBuild,
+ },
+ {
+ A: HumanProtocolVersion{0, 0, 0, 0, 0, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 3, 3, 3, [8]byte{3}},
+ Cmp: EmptyVersion,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 1, [8]byte{}},
+ Cmp: AheadMajor,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 1, 0, 0, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 1, 0, 1, [8]byte{}},
+ Cmp: AheadMinor,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 0, 1, 0, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 1, 1, [8]byte{}},
+ Cmp: AheadPatch,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 0, 0, 2, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 1, [8]byte{}},
+ Cmp: AheadPrerelease,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 1, 0, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ Cmp: AheadPatch,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 0, 1, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ Cmp: AheadPrerelease,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 1, 1, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ Cmp: AheadMinor,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 0, 2, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ Cmp: AheadPatch,
+ },
+ {
+ A: HumanProtocolVersion{0, 5, 0, 1, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ Cmp: AheadMajor,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, 0, 0, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 0, 9, 0, 0, [8]byte{}},
+ Cmp: AheadMinor,
+ },
+ {
+ A: HumanProtocolVersion{0, 0, 1, 0, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 0, 0, 9, 0, [8]byte{}},
+ Cmp: AheadPatch,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, ^uint32(0), 0, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 0, 1, 0, 0, [8]byte{}},
+ Cmp: InvalidVersion,
+ },
+ }
+ for i, tc := range testCases {
+ tc := tc // not a parallel sub-test, but better than a flake
+ t.Run(fmt.Sprintf("case_%d", i), func(t *testing.T) {
+ a := ProtocolVersionV0{tc.A.Build, tc.A.Major, tc.A.Minor, tc.A.Patch, tc.A.Prerelease}.Encode()
+ a[0] = tc.A.VersionType
+ b := ProtocolVersionV0{tc.B.Build, tc.B.Major, tc.B.Minor, tc.B.Patch, tc.B.Prerelease}.Encode()
+ b[0] = tc.B.VersionType
+ cmp := a.Compare(b)
+ if cmp != tc.Cmp {
+ t.Fatalf("expected %d but got %d", tc.Cmp, cmp)
+ }
+ switch tc.Cmp {
+ case AheadMajor, AheadMinor, AheadPatch, AheadPrerelease:
+ inv := b.Compare(a)
+ if inv != -tc.Cmp {
+ t.Fatalf("expected inverse when reversing the comparison, %d but got %d", -tc.Cmp, inv)
+ }
+ case DiffVersionType, DiffBuild, EmptyVersion, Matching:
+ inv := b.Compare(a)
+ if inv != tc.Cmp {
+ t.Fatalf("expected comparison reversed to hold the same, expected %d but got %d", tc.Cmp, inv)
+ }
+ }
+ })
+ }
+}
+func TestProtocolVersion_String(t *testing.T) {
+ testCases := []struct {
+ version ProtocolVersion
+ expected string
+ }{
+ {ProtocolVersionV0{[8]byte{}, 0, 0, 0, 0}.Encode(), "v0.0.0"},
+ {ProtocolVersionV0{[8]byte{}, 0, 0, 0, 1}.Encode(), "v0.0.0-1"},
+ {ProtocolVersionV0{[8]byte{}, 0, 0, 1, 0}.Encode(), "v0.0.1"},
+ {ProtocolVersionV0{[8]byte{}, 4, 3, 2, 1}.Encode(), "v4.3.2-1"},
+ {ProtocolVersionV0{[8]byte{}, 0, 100, 2, 0}.Encode(), "v0.100.2"},
+ {ProtocolVersionV0{[8]byte{'O', 'P', '-', 'm', 'o', 'd'}, 42, 0, 2, 1}.Encode(), "v42.0.2-1+OP-mod"},
+ {ProtocolVersionV0{[8]byte{'b', 'e', 't', 'a', '.', '1', '2', '3'}, 1, 0, 0, 0}.Encode(), "v1.0.0+beta.123"},
+ {ProtocolVersionV0{[8]byte{'a', 'b', 1}, 42, 0, 2, 0}.Encode(), "v42.0.2+0x6162010000000000"}, // do not render invalid alpha numeric
+ {ProtocolVersionV0{[8]byte{1, 2, 3, 4, 5, 6, 7, 8}, 42, 0, 2, 0}.Encode(), "v42.0.2+0x0102030405060708"},
+ }
+ for _, tc := range testCases {
+ t.Run(tc.expected, func(t *testing.T) {
+ got := tc.version.String()
+ if got != tc.expected {
+ t.Fatalf("got %q but expected %q", got, tc.expected)
+ }
+ })
+ }
+}
diff --git go-ethereum/rlp/decode_test.go op-geth/rlp/decode_test.go
index 07d9c579a6a47e709b29e8ad0d85c5986aab038d..2f74395f3427cddf018a333f1d9c5ccfe271bebb 100644
--- go-ethereum/rlp/decode_test.go
+++ op-geth/rlp/decode_test.go
@@ -27,8 +27,8 @@ "reflect"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/common/math"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common/math"
)
func TestStreamKind(t *testing.T) {
diff --git go-ethereum/rlp/encbuffer_example_test.go op-geth/rlp/encbuffer_example_test.go
index ee15d82a77b91c2cfb49005f46aa7eb04b250d88..c0ba2efb98163b5e7421809189d21e73a0c39830 100644
--- go-ethereum/rlp/encbuffer_example_test.go
+++ op-geth/rlp/encbuffer_example_test.go
@@ -20,7 +20,7 @@ import (
"bytes"
"fmt"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/rlp"
)
func ExampleEncoderBuffer() {
diff --git go-ethereum/rlp/encode_test.go op-geth/rlp/encode_test.go
index 314958eb560409564ebe90f1ff40e4b261ff1606..00b2ebb62802edf3eb5858d24e9cf8491765b5cb 100644
--- go-ethereum/rlp/encode_test.go
+++ op-geth/rlp/encode_test.go
@@ -26,8 +26,8 @@ "runtime"
"sync"
"testing"
- "github.com/ethereum/go-ethereum/common/math"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common/math"
)
type testEncoder struct {
diff --git go-ethereum/rlp/encoder_example_test.go op-geth/rlp/encoder_example_test.go
index 4cd3cb8673754a23d1b99ecaf0a4017c7c245f4b..02e908f49328432b0e97ab5ddb347f89176a659b 100644
--- go-ethereum/rlp/encoder_example_test.go
+++ op-geth/rlp/encoder_example_test.go
@@ -20,7 +20,7 @@ import (
"fmt"
"io"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/rlp"
)
type MyCoolType struct {
diff --git go-ethereum/rlp/iterator_test.go op-geth/rlp/iterator_test.go
index a22aaec862120fd99e333219b46757a168c13ccd..dfc997a13778885c114e946e72d17692b1bf2ff0 100644
--- go-ethereum/rlp/iterator_test.go
+++ op-geth/rlp/iterator_test.go
@@ -19,7 +19,7 @@
import (
"testing"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common/hexutil"
)
// TestIterator tests some basic things about the ListIterator. A more
diff --git go-ethereum/rpc/client_example_test.go op-geth/rpc/client_example_test.go
index 044b57a9c439c3e66b100f0676c658e06f1dd62d..2d0b3a0053fe89bd33b96aeef6dac5a7748ddf89 100644
--- go-ethereum/rpc/client_example_test.go
+++ op-geth/rpc/client_example_test.go
@@ -21,8 +21,8 @@ "context"
"fmt"
"time"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/rpc"
)
// In this example, our client wishes to track the latest 'block number'
diff --git go-ethereum/rpc/client_opt_test.go op-geth/rpc/client_opt_test.go
index d7cc2572a776f0c6193329b0955c7179d4659851..b0b2cf09d2043ab3a27e667463eb2f96fd603ace 100644
--- go-ethereum/rpc/client_opt_test.go
+++ op-geth/rpc/client_opt_test.go
@@ -5,7 +5,7 @@ "context"
"net/http"
"time"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/rpc"
)
// This example configures a HTTP-based RPC client with two options - one setting the
diff --git go-ethereum/rpc/client_test.go op-geth/rpc/client_test.go
index ac02ad33cf6a7a4c389c72ec54e96bdb92bc5bf0..0dce7b1da756f7c02e9b923993b702f2cce915ab 100644
--- go-ethereum/rpc/client_test.go
+++ op-geth/rpc/client_test.go
@@ -34,7 +34,7 @@ "testing"
"time"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
func TestClientRequest(t *testing.T) {
@@ -493,7 +493,7 @@ t.Fatalf("Subscribe did not return within 1s after Close")
}
}
-// This test reproduces https://github.com/ethereum/go-ethereum/issues/17837 where the
+// This test reproduces https://github.com/tenderly/op-geth/issues/17837 where the
// client hangs during shutdown when Unsubscribe races with Client.Close.
func TestClientCloseUnsubscribeRace(t *testing.T) {
server := newTestServer()
@@ -578,14 +578,14 @@ }
}
// This checks that the subscribed channel can be closed after Unsubscribe.
-// It is the reproducer for https://github.com/ethereum/go-ethereum/issues/22322
+// It is the reproducer for https://github.com/tenderly/op-geth/issues/22322
func TestClientSubscriptionChannelClose(t *testing.T) {
t.Parallel()
var (
srv = NewServer()
httpsrv = httptest.NewServer(srv.WebsocketHandler(nil))
- wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:")
+ wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:") //nolint:all
)
defer srv.Stop()
defer httpsrv.Close()
diff --git go-ethereum/rpc/subscription_test.go op-geth/rpc/subscription_test.go
index 3a131c8e6bd2a6e46fc2043530eb01d1d36af9cc..1195b54d74665d7a26908f6931cd9b921772b596 100644
--- go-ethereum/rpc/subscription_test.go
+++ op-geth/rpc/subscription_test.go
@@ -28,8 +28,8 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
)
func TestNewID(t *testing.T) {
diff --git go-ethereum/rpc/types_test.go op-geth/rpc/types_test.go
index 617f441d9166b53054108665a567b661c7e8fd8c..847c24880932fc15cd108c810fce22e7fe9505fb 100644
--- go-ethereum/rpc/types_test.go
+++ op-geth/rpc/types_test.go
@@ -21,8 +21,8 @@ "encoding/json"
"reflect"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
)
func TestBlockNumberJSONUnmarshal(t *testing.T) {
diff --git go-ethereum/rpc/websocket_test.go op-geth/rpc/websocket_test.go
index 8d2bd9d802bdb6a37d0b36b76fb3eb3c35983d21..07ca649ca829553a34535eb98f8764fea334f4ee 100644
--- go-ethereum/rpc/websocket_test.go
+++ op-geth/rpc/websocket_test.go
@@ -235,7 +235,7 @@ // Note: Unsubscribe is not called on this subscription because the mockup
// server can't handle the request.
// Wait for the context's deadline to be reached before proceeding.
- // This is important for reproducing https://github.com/ethereum/go-ethereum/issues/19798
+ // This is important for reproducing https://github.com/tenderly/op-geth/issues/19798
<-ctx.Done()
close(sendPing)
diff --git go-ethereum/signer/core/api_test.go op-geth/signer/core/api_test.go
index 69229dadaf264bfd3a4281011ac6ee92a04bae04..5e92f5cbab30582ccea96fb6d7820d9ed5f4b0a3 100644
--- go-ethereum/signer/core/api_test.go
+++ op-geth/signer/core/api_test.go
@@ -26,17 +26,17 @@ "path/filepath"
"testing"
"time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/signer/core"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
- "github.com/ethereum/go-ethereum/signer/fourbyte"
- "github.com/ethereum/go-ethereum/signer/storage"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/signer/core"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
+ "github.com/tenderly/op-geth/signer/fourbyte"
+ "github.com/tenderly/op-geth/signer/storage"
)
// Used for testing
diff --git go-ethereum/signer/core/apitypes/signed_data_internal_test.go op-geth/signer/core/apitypes/signed_data_internal_test.go
index 8067893c213443b75b44323a16495370f7caa872..2bdb923b9cc6a1d25e74fdd04e170ab7eb58ea51 100644
--- go-ethereum/signer/core/apitypes/signed_data_internal_test.go
+++ op-geth/signer/core/apitypes/signed_data_internal_test.go
@@ -21,9 +21,9 @@ "bytes"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
)
func TestBytesPadding(t *testing.T) {
diff --git go-ethereum/signer/core/signed_data_test.go op-geth/signer/core/signed_data_test.go
index 1cf8b4bf381389d302987c32331754475b3a33a0..a0a14282188c0fc98ed174127aa8a8f297b5c13b 100644
--- go-ethereum/signer/core/signed_data_test.go
+++ op-geth/signer/core/signed_data_test.go
@@ -27,13 +27,13 @@ "path"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/signer/core"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/signer/core"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
)
var typesStandard = apitypes.Types{
diff --git go-ethereum/signer/fourbyte/abi_test.go op-geth/signer/fourbyte/abi_test.go
index 9656732dff9cf30edd98241d5f9b49a0df66f935..0775054044c5bf438e3dfe3b2731b789d3adfc5d 100644
--- go-ethereum/signer/fourbyte/abi_test.go
+++ op-geth/signer/fourbyte/abi_test.go
@@ -22,8 +22,8 @@ "reflect"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/accounts/abi"
+ "github.com/tenderly/op-geth/common"
)
func verify(t *testing.T, jsondata, calldata string, exp []interface{}) {
diff --git go-ethereum/signer/fourbyte/fourbyte_test.go op-geth/signer/fourbyte/fourbyte_test.go
index a3dc3b511707829bd8e767e80b365fd8ee0ceda9..837f7ebdce0184096846120cdeba516471e5ee93 100644
--- go-ethereum/signer/fourbyte/fourbyte_test.go
+++ op-geth/signer/fourbyte/fourbyte_test.go
@@ -21,8 +21,8 @@ "encoding/json"
"fmt"
"testing"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/accounts/abi"
+ "github.com/tenderly/op-geth/common"
)
// Tests that all the selectors contained in the 4byte database are valid.
diff --git go-ethereum/signer/fourbyte/validation_test.go op-geth/signer/fourbyte/validation_test.go
index 74fed9fe01267f99a8d0ca5eb90b25d3043fcf4d..383d4046990b8aced455a4ed690a9e8c426656d3 100644
--- go-ethereum/signer/fourbyte/validation_test.go
+++ op-geth/signer/fourbyte/validation_test.go
@@ -20,9 +20,9 @@ import (
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
)
func mixAddr(a string) (*common.MixedcaseAddress, error) {
diff --git go-ethereum/signer/rules/rules_test.go op-geth/signer/rules/rules_test.go
index d27de22b29a9acd247c65714e68f8b2198cf1684..ad4b16551435cc0c827ecc83edd5fae99d9ff308 100644
--- go-ethereum/signer/rules/rules_test.go
+++ op-geth/signer/rules/rules_test.go
@@ -22,14 +22,14 @@ "math/big"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/signer/core"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
- "github.com/ethereum/go-ethereum/signer/storage"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/signer/core"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
+ "github.com/tenderly/op-geth/signer/storage"
)
const JS = `
diff --git go-ethereum/signer/storage/aes_gcm_storage_test.go op-geth/signer/storage/aes_gcm_storage_test.go
index a223b1a6b4e7e6fdcf9207166e85cf44be73868d..21468f4af765987f19ccd5a971f1b718026da914 100644
--- go-ethereum/signer/storage/aes_gcm_storage_test.go
+++ op-geth/signer/storage/aes_gcm_storage_test.go
@@ -23,9 +23,9 @@ "fmt"
"os"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/log"
"github.com/mattn/go-colorable"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/log"
"golang.org/x/exp/slog"
)
diff --git go-ethereum/tests/block_test.go op-geth/tests/block_test.go
index fb355085fd8c106df6f957c7c066fafd93d2a82b..fa6bbd22d193b2df83461fea923a10615f543ac8 100644
--- go-ethereum/tests/block_test.go
+++ op-geth/tests/block_test.go
@@ -21,8 +21,8 @@ "math/rand"
"runtime"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
)
func TestBlockchain(t *testing.T) {
diff --git go-ethereum/tests/difficulty_test.go op-geth/tests/difficulty_test.go
index 03e14df7c4df56e645300c46d0990472cc4a7bde..15236813dfa4999b00cf134c8f7e8c82d239fdb5 100644
--- go-ethereum/tests/difficulty_test.go
+++ op-geth/tests/difficulty_test.go
@@ -20,7 +20,7 @@ import (
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/params"
)
var (
diff --git go-ethereum/tests/init_test.go op-geth/tests/init_test.go
index e9bb99dc7d013b182bba7cf9e513a26e3488f60d..a78caf481ff088f2abf17dbc26ad7f28456db4f5 100644
--- go-ethereum/tests/init_test.go
+++ op-geth/tests/init_test.go
@@ -30,7 +30,7 @@ "sort"
"strings"
"testing"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/params"
)
var (
diff --git go-ethereum/tests/state_test.go op-geth/tests/state_test.go
index 1d749d8bcf52b4fd55f1b63d3b4c86359cef38c6..8ab7e4c53a8b427403be59f6a4629f32626ec5cb 100644
--- go-ethereum/tests/state_test.go
+++ op-geth/tests/state_test.go
@@ -30,13 +30,13 @@ "strings"
"testing"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers/logger"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers/logger"
)
func initMatcher(st *testMatcher) {
@@ -284,7 +284,7 @@ }
// Prepare the EVM.
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(block.Header(), nil, &t.json.Env.Coinbase)
+ context := core.NewEVMBlockContext(block.Header(), nil, &t.json.Env.Coinbase, config, state.StateDB)
context.GetHash = vmTestBlockHash
context.BaseFee = baseFee
evm := vm.NewEVM(context, txContext, state.StateDB, config, vmconfig)
diff --git go-ethereum/tests/transaction_test.go op-geth/tests/transaction_test.go
index cb0f2623189c34a2dcba5871ac8c6a3d7b6ec3fb..22037860e0535e707c32e2485e304cfc9ab0a9a1 100644
--- go-ethereum/tests/transaction_test.go
+++ op-geth/tests/transaction_test.go
@@ -19,7 +19,7 @@
import (
"testing"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/params"
)
func TestTransaction(t *testing.T) {
diff --git go-ethereum/trie/database_test.go op-geth/trie/database_test.go
index aed508b368ca2e2166fe778422af0d58df75063c..2b8d44dc8e9709d0cfea9365506cbfad369d7e30 100644
--- go-ethereum/trie/database_test.go
+++ op-geth/trie/database_test.go
@@ -17,12 +17,12 @@
package trie
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/triedb/database"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/triedb/database"
)
// testReader implements database.Reader interface, providing function to
diff --git go-ethereum/trie/iterator_test.go op-geth/trie/iterator_test.go
index 41e83f6cb69e8789efe103eb86703c8bba0ef741..4396322caf802b35794fc01c0b28b8300dc1ab60 100644
--- go-ethereum/trie/iterator_test.go
+++ op-geth/trie/iterator_test.go
@@ -22,11 +22,11 @@ "fmt"
"math/rand"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/trie/trienode"
)
func TestEmptyIterator(t *testing.T) {
diff --git go-ethereum/trie/node_test.go op-geth/trie/node_test.go
index 9b8b33748fa7ed09c45e1f1d2cfde68b6289363f..33fb5f04830b3f0e42c46dbcce6198a0f00069cb 100644
--- go-ethereum/trie/node_test.go
+++ op-geth/trie/node_test.go
@@ -20,8 +20,8 @@ import (
"bytes"
"testing"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
)
func newTestFullNode(v []byte) []interface{} {
@@ -96,7 +96,7 @@ }
// goos: darwin
// goarch: arm64
-// pkg: github.com/ethereum/go-ethereum/trie
+// pkg: github.com/tenderly/op-geth/trie
// BenchmarkEncodeShortNode
// BenchmarkEncodeShortNode-8 16878850 70.81 ns/op 48 B/op 1 allocs/op
func BenchmarkEncodeShortNode(b *testing.B) {
@@ -114,7 +114,7 @@ }
// goos: darwin
// goarch: arm64
-// pkg: github.com/ethereum/go-ethereum/trie
+// pkg: github.com/tenderly/op-geth/trie
// BenchmarkEncodeFullNode
// BenchmarkEncodeFullNode-8 4323273 284.4 ns/op 576 B/op 1 allocs/op
func BenchmarkEncodeFullNode(b *testing.B) {
@@ -132,7 +132,7 @@ }
// goos: darwin
// goarch: arm64
-// pkg: github.com/ethereum/go-ethereum/trie
+// pkg: github.com/tenderly/op-geth/trie
// BenchmarkDecodeShortNode
// BenchmarkDecodeShortNode-8 7925638 151.0 ns/op 157 B/op 4 allocs/op
func BenchmarkDecodeShortNode(b *testing.B) {
@@ -153,7 +153,7 @@ }
// goos: darwin
// goarch: arm64
-// pkg: github.com/ethereum/go-ethereum/trie
+// pkg: github.com/tenderly/op-geth/trie
// BenchmarkDecodeShortNodeUnsafe
// BenchmarkDecodeShortNodeUnsafe-8 9027476 128.6 ns/op 109 B/op 3 allocs/op
func BenchmarkDecodeShortNodeUnsafe(b *testing.B) {
@@ -174,7 +174,7 @@ }
// goos: darwin
// goarch: arm64
-// pkg: github.com/ethereum/go-ethereum/trie
+// pkg: github.com/tenderly/op-geth/trie
// BenchmarkDecodeFullNode
// BenchmarkDecodeFullNode-8 1597462 761.9 ns/op 1280 B/op 18 allocs/op
func BenchmarkDecodeFullNode(b *testing.B) {
@@ -195,7 +195,7 @@ }
// goos: darwin
// goarch: arm64
-// pkg: github.com/ethereum/go-ethereum/trie
+// pkg: github.com/tenderly/op-geth/trie
// BenchmarkDecodeFullNodeUnsafe
// BenchmarkDecodeFullNodeUnsafe-8 1789070 687.1 ns/op 704 B/op 17 allocs/op
func BenchmarkDecodeFullNodeUnsafe(b *testing.B) {
diff --git go-ethereum/trie/proof_test.go op-geth/trie/proof_test.go
index 5471d0efa6bb88ffdf1dad4c175700479aadd68c..8057a4238c13cbde86e49a03f441f719c2b47e55 100644
--- go-ethereum/trie/proof_test.go
+++ op-geth/trie/proof_test.go
@@ -24,10 +24,10 @@ "fmt"
mrand "math/rand"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb/memorydb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb/memorydb"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/trie/secure_trie_test.go op-geth/trie/secure_trie_test.go
index 0a6fd688b7ea14a03a89984d8918dbd0a43531b2..634a0a0dcf2b1c3ec5df3bc16a86fd3511fbda80 100644
--- go-ethereum/trie/secure_trie_test.go
+++ op-geth/trie/secure_trie_test.go
@@ -23,11 +23,11 @@ "runtime"
"sync"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/trie/trienode"
)
func newEmptySecure() *StateTrie {
diff --git go-ethereum/trie/stacktrie_fuzzer_test.go op-geth/trie/stacktrie_fuzzer_test.go
index c8e568355c3801c90cbffc3639b2ce7eda1868b2..ce9ab37f60709e7de942f1070b4dfbd0ee1ff608 100644
--- go-ethereum/trie/stacktrie_fuzzer_test.go
+++ op-geth/trie/stacktrie_fuzzer_test.go
@@ -22,11 +22,11 @@ "encoding/binary"
"fmt"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/trie/trienode"
"golang.org/x/crypto/sha3"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/trie/stacktrie_test.go op-geth/trie/stacktrie_test.go
index f053b5112d3f8ef6a1eb90aa5f8ea916801589c4..73c4ff7a77eaea9a8d3f483b0996b24d5a1c6d1e 100644
--- go-ethereum/trie/stacktrie_test.go
+++ op-geth/trie/stacktrie_test.go
@@ -21,10 +21,10 @@ "bytes"
"math/big"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/crypto"
"github.com/stretchr/testify/assert"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/crypto"
)
func TestStackTrieInsertAndHash(t *testing.T) {
diff --git go-ethereum/trie/sync_test.go op-geth/trie/sync_test.go
index 7bc68c041fdc1a919dc061e2dd4ccde2938fff6e..c294ee9a97ac2c15e9eb7077cd20371751a7c65e 100644
--- go-ethereum/trie/sync_test.go
+++ op-geth/trie/sync_test.go
@@ -22,13 +22,13 @@ "fmt"
"math/rand"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/ethdb/memorydb"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/ethdb/memorydb"
+ "github.com/tenderly/op-geth/trie/trienode"
)
// makeTestTrie create a sample test trie to test node-wise reconstruction.
diff --git go-ethereum/trie/tracer_test.go op-geth/trie/tracer_test.go
index 27e42d497af0a5a16f7595e93615b2293f97b8d6..3b0cc843ca73d3d981e7edc0bc4fed91d6f456a0 100644
--- go-ethereum/trie/tracer_test.go
+++ op-geth/trie/tracer_test.go
@@ -20,10 +20,10 @@ import (
"bytes"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/trie/trienode"
)
var (
diff --git go-ethereum/trie/trie_test.go op-geth/trie/trie_test.go
index c141c5207886e970846dee4b7f62916c92843a8a..6e09e78634ef2cea93d229ccaac54c6a1f2a48eb 100644
--- go-ethereum/trie/trie_test.go
+++ op-geth/trie/trie_test.go
@@ -30,14 +30,14 @@ "testing"
"testing/quick"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie/trienode"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie/trienode"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/trie/utils/verkle_test.go op-geth/trie/utils/verkle_test.go
index 28b059c3794edcf72eb33da87cbdfec3db79289b..cf9c6889aaaaffc373f7265f9848afd75e326773 100644
--- go-ethereum/trie/utils/verkle_test.go
+++ op-geth/trie/utils/verkle_test.go
@@ -64,7 +64,7 @@ }
// goos: darwin
// goarch: amd64
-// pkg: github.com/ethereum/go-ethereum/trie/utils
+// pkg: github.com/tenderly/op-geth/trie/utils
// cpu: VirtualApple @ 2.50GHz
// BenchmarkTreeKey
// BenchmarkTreeKey-8 398731 2961 ns/op 32 B/op 1 allocs/op
@@ -82,7 +82,7 @@ }
// goos: darwin
// goarch: amd64
-// pkg: github.com/ethereum/go-ethereum/trie/utils
+// pkg: github.com/tenderly/op-geth/trie/utils
// cpu: VirtualApple @ 2.50GHz
// BenchmarkTreeKeyWithEvaluation
// BenchmarkTreeKeyWithEvaluation-8 513855 2324 ns/op 32 B/op 1 allocs/op
@@ -102,7 +102,7 @@ }
// goos: darwin
// goarch: amd64
-// pkg: github.com/ethereum/go-ethereum/trie/utils
+// pkg: github.com/tenderly/op-geth/trie/utils
// cpu: VirtualApple @ 2.50GHz
// BenchmarkStorageKey
// BenchmarkStorageKey-8 230516 4584 ns/op 96 B/op 3 allocs/op
@@ -120,7 +120,7 @@ }
// goos: darwin
// goarch: amd64
-// pkg: github.com/ethereum/go-ethereum/trie/utils
+// pkg: github.com/tenderly/op-geth/trie/utils
// cpu: VirtualApple @ 2.50GHz
// BenchmarkStorageKeyWithEvaluation
// BenchmarkStorageKeyWithEvaluation-8 320125 3753 ns/op 96 B/op 3 allocs/op
diff --git go-ethereum/trie/verkle_test.go op-geth/trie/verkle_test.go
index 0cbe28bf0192f5f70402de8db2ea09a5c40789f0..8501fa59b8b45ff957d86b11c8d3c3ffd3f29497 100644
--- go-ethereum/trie/verkle_test.go
+++ op-geth/trie/verkle_test.go
@@ -21,11 +21,11 @@ "bytes"
"reflect"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/trie/utils"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/trie/utils"
)
var (
diff --git go-ethereum/triedb/pathdb/database_test.go op-geth/triedb/pathdb/database_test.go
index e7bd4699938de4a425f4c7631616dc5851e3b100..609760c17fda39b8db506877908259064dc6408f 100644
--- go-ethereum/triedb/pathdb/database_test.go
+++ op-geth/triedb/pathdb/database_test.go
@@ -23,15 +23,15 @@ "fmt"
"math/rand"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie/testutil"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/triestate"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie/testutil"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/triestate"
)
func updateTrie(addrHash common.Hash, root common.Hash, dirties, cleans map[common.Hash][]byte) (common.Hash, *trienode.NodeSet) {
diff --git go-ethereum/triedb/pathdb/difflayer_test.go op-geth/triedb/pathdb/difflayer_test.go
index 9b5907c3c5b30db61aa697b7c6dcfd97c17b36e6..41bb01d3733bf68ef708c316fb2c44b694c8344e 100644
--- go-ethereum/triedb/pathdb/difflayer_test.go
+++ op-geth/triedb/pathdb/difflayer_test.go
@@ -20,10 +20,10 @@ import (
"bytes"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/trie/testutil"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/trie/testutil"
+ "github.com/tenderly/op-geth/trie/trienode"
)
func emptyLayer() *diskLayer {
@@ -35,21 +35,21 @@ }
// goos: darwin
// goarch: arm64
-// pkg: github.com/ethereum/go-ethereum/trie
+// pkg: github.com/tenderly/op-geth/trie
// BenchmarkSearch128Layers
// BenchmarkSearch128Layers-8 243826 4755 ns/op
func BenchmarkSearch128Layers(b *testing.B) { benchmarkSearch(b, 0, 128) }
// goos: darwin
// goarch: arm64
-// pkg: github.com/ethereum/go-ethereum/trie
+// pkg: github.com/tenderly/op-geth/trie
// BenchmarkSearch512Layers
// BenchmarkSearch512Layers-8 49686 24256 ns/op
func BenchmarkSearch512Layers(b *testing.B) { benchmarkSearch(b, 0, 512) }
// goos: darwin
// goarch: arm64
-// pkg: github.com/ethereum/go-ethereum/trie
+// pkg: github.com/tenderly/op-geth/trie
// BenchmarkSearch1Layer
// BenchmarkSearch1Layer-8 14062725 88.40 ns/op
func BenchmarkSearch1Layer(b *testing.B) { benchmarkSearch(b, 127, 128) }
@@ -102,7 +102,7 @@ }
// goos: darwin
// goarch: arm64
-// pkg: github.com/ethereum/go-ethereum/trie
+// pkg: github.com/tenderly/op-geth/trie
// BenchmarkPersist
// BenchmarkPersist-8 10 111252975 ns/op
func BenchmarkPersist(b *testing.B) {
diff --git go-ethereum/triedb/pathdb/history_test.go op-geth/triedb/pathdb/history_test.go
index a3257441de806c77fe1ce5cd9c1ffb39c9432750..f47678668adcd22242c38b168d948cd8f1048835 100644
--- go-ethereum/triedb/pathdb/history_test.go
+++ op-geth/triedb/pathdb/history_test.go
@@ -22,13 +22,13 @@ "fmt"
"reflect"
"testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie/testutil"
- "github.com/ethereum/go-ethereum/trie/triestate"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie/testutil"
+ "github.com/tenderly/op-geth/trie/triestate"
)
// randomStateSet generates a random state change set.
Other changes
+2111
-23922
diff --git go-ethereum/.travis.yml op-geth/.travis.yml
index a55583a703febc6a861a5b41b8d70352724eb02f..c6cf34406621d2d3da2134e92449cdac17b90847 100644
--- go-ethereum/.travis.yml
+++ op-geth/.travis.yml
@@ -1,5 +1,5 @@
language: go
-go_import_path: github.com/ethereum/go-ethereum
+go_import_path: github.com/tenderly/op-geth
sudo: false
jobs:
allow_failures:
diff --git go-ethereum/README.md op-geth/README.md
index 1e8dba80909486832a01f1226ce1c98d2383cf94..dd0650a3487fd53467c614ab09c7b86d296b080f 100644
--- go-ethereum/README.md
+++ op-geth/README.md
@@ -3,9 +3,9 @@
Golang execution layer implementation of the Ethereum protocol.
[](https://pkg.go.dev/github.com/ethereum/go-ethereum?tab=doc)
-[](https://goreportcard.com/report/github.com/ethereum/go-ethereum)
+https://pkg.go.dev/badge/github.com/tenderly/op-geth
+)](https://pkg.go.dev/github.com/tenderly/op-geth?tab=doc)
+[](https://goreportcard.com/report/github.com/tenderly/op-geth)
[](https://app.travis-ci.com/github/ethereum/go-ethereum)
[](https://discord.gg/nthXNEv)
@@ -344,7 +344,7 @@
### Contributing to geth.ethereum.org
For contributions to the [go-ethereum website](https://geth.ethereum.org), please checkout and raise pull requests against the `website` branch.
-For more detailed instructions please see the `website` branch [README](https://github.com/ethereum/go-ethereum/tree/website#readme) or the
+For more detailed instructions please see the `website` branch [README](https://github.com/tenderly/op-geth/tree/website#readme) or the
[contributing](https://geth.ethereum.org/docs/developers/geth-developer/contributing) page of the website.
## License
diff --git go-ethereum/SECURITY.md op-geth/SECURITY.md
index 41b900d5e98432f6c49ea3830349d912781fe0ff..6e83d452fde2fc4c05aebc56a6bb7b7a2797c6bf 100644
--- go-ethereum/SECURITY.md
+++ op-geth/SECURITY.md
@@ -2,24 +2,24 @@ # Security Policy
## Supported Versions
-Please see [Releases](https://github.com/ethereum/go-ethereum/releases). We recommend using the [most recently released version](https://github.com/ethereum/go-ethereum/releases/latest).
+Please see [Releases](https://github.com/tenderly/op-geth/releases). We recommend using the [most recently released version](https://github.com/tenderly/op-geth/releases/latest).
## Audit reports
-Audit reports are published in the `docs` folder: https://github.com/ethereum/go-ethereum/tree/master/docs/audits
+Audit reports are published in the `docs` folder: https://github.com/tenderly/op-geth/tree/master/docs/audits
| Scope | Date | Report Link |
| ------- | ------- | ----------- |
-| `geth` | 20170425 | [pdf](https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2017-04-25_Geth-audit_Truesec.pdf) |
-| `clef` | 20180914 | [pdf](https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2018-09-14_Clef-audit_NCC.pdf) |
-| `Discv5` | 20191015 | [pdf](https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2019-10-15_Discv5_audit_LeastAuthority.pdf) |
-| `Discv5` | 20200124 | [pdf](https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2020-01-24_DiscV5_audit_Cure53.pdf) |
+| `geth` | 20170425 | [pdf](https://github.com/tenderly/op-geth/blob/master/docs/audits/2017-04-25_Geth-audit_Truesec.pdf) |
+| `clef` | 20180914 | [pdf](https://github.com/tenderly/op-geth/blob/master/docs/audits/2018-09-14_Clef-audit_NCC.pdf) |
+| `Discv5` | 20191015 | [pdf](https://github.com/tenderly/op-geth/blob/master/docs/audits/2019-10-15_Discv5_audit_LeastAuthority.pdf) |
+| `Discv5` | 20200124 | [pdf](https://github.com/tenderly/op-geth/blob/master/docs/audits/2020-01-24_DiscV5_audit_Cure53.pdf) |
## Reporting a Vulnerability
**Please do not file a public ticket** mentioning the vulnerability.
-To find out how to disclose a vulnerability in Ethereum visit [https://bounty.ethereum.org](https://bounty.ethereum.org) or email bounty@ethereum.org. Please read the [disclosure page](https://github.com/ethereum/go-ethereum/security/advisories?state=published) for more information about publicly disclosed security vulnerabilities.
+To find out how to disclose a vulnerability in Ethereum visit [https://bounty.ethereum.org](https://bounty.ethereum.org) or email bounty@ethereum.org. Please read the [disclosure page](https://github.com/tenderly/op-geth/security/advisories?state=published) for more information about publicly disclosed security vulnerabilities.
Use the built-in `geth version-check` feature to check whether the software is affected by any known vulnerability. This command will fetch the latest [`vulnerabilities.json`](https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities.json) file which contains known security vulnerabilities concerning `geth`, and cross-check the data against its own version number.
diff --git go-ethereum/accounts/abi/abi.go op-geth/accounts/abi/abi.go
index c7bc2b4541f4da8a03dedfbee526d5b45d83b7d5..a3ee84844d9c3c781c0c5c530a0756c47b11d761 100644
--- go-ethereum/accounts/abi/abi.go
+++ op-geth/accounts/abi/abi.go
@@ -24,8 +24,8 @@ "fmt"
"io"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
)
// The ABI holds information about a contract's context and available
diff --git go-ethereum/accounts/abi/bind/auth.go op-geth/accounts/abi/bind/auth.go
index 0740c69510256169934ac733bbe769f0c483038e..221c386e58e583db507a44ae5414c86d02426981 100644
--- go-ethereum/accounts/abi/bind/auth.go
+++ op-geth/accounts/abi/bind/auth.go
@@ -23,13 +23,13 @@ "errors"
"io"
"math/big"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/external"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/external"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
)
// ErrNoChainID is returned whenever the user failed to specify a chain id.
diff --git go-ethereum/accounts/abi/bind/backend.go op-geth/accounts/abi/bind/backend.go
index 38b30469708d0f25646ca7c54b91ecf8a75d4113..e094bb756c85d4bcf5ea7896b85f06d0803d29bf 100644
--- go-ethereum/accounts/abi/bind/backend.go
+++ op-geth/accounts/abi/bind/backend.go
@@ -21,9 +21,9 @@ "context"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
)
var (
diff --git go-ethereum/accounts/abi/bind/base.go op-geth/accounts/abi/bind/base.go
index 96d284cdcc0c8413e5cbeb6b6ed29a447629bbda..d0e31475551505f4985387b1fcfe0f5065267c0c 100644
--- go-ethereum/accounts/abi/bind/base.go
+++ op-geth/accounts/abi/bind/base.go
@@ -24,12 +24,12 @@ "math/big"
"strings"
"sync"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/event"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts/abi"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/event"
)
const basefeeWiggleMultiplier = 2
diff --git go-ethereum/accounts/abi/bind/bind.go op-geth/accounts/abi/bind/bind.go
index e902345f090a230cd5eecfb4dcdcf4144ce84eed..eebfc0d875b8282aa3603801fe5e6d3d0c622ef8 100644
--- go-ethereum/accounts/abi/bind/bind.go
+++ op-geth/accounts/abi/bind/bind.go
@@ -17,7 +17,7 @@
// Package bind generates Ethereum contract Go bindings.
//
// Detailed usage document and tutorial available on the go-ethereum Wiki page:
-// https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts
+// https://github.com/tenderly/op-geth/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts
package bind
import (
@@ -29,8 +29,8 @@ "strings"
"text/template"
"unicode"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/accounts/abi"
+ "github.com/tenderly/op-geth/log"
)
// Lang is a target programming language selector to generate bindings for.
diff --git go-ethereum/accounts/abi/bind/template.go op-geth/accounts/abi/bind/template.go
index 95dc13cc188e2c8ff17639514c5b2b58ed20d43d..812fd2c3fcf84de848cc100e704ade635dac88c8 100644
--- go-ethereum/accounts/abi/bind/template.go
+++ op-geth/accounts/abi/bind/template.go
@@ -16,7 +16,7 @@ // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
package bind
-import "github.com/ethereum/go-ethereum/accounts/abi"
+import "github.com/tenderly/op-geth/accounts/abi"
// tmplData is the data structure required to fill the binding template.
type tmplData struct {
@@ -91,12 +91,12 @@ "math/big"
"strings"
"errors"
- ethereum "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/event"
+ ethereum "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts/abi"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/event"
)
// Reference imports to suppress errors if they are not otherwise used.
diff --git go-ethereum/accounts/abi/bind/util.go op-geth/accounts/abi/bind/util.go
index b931fbb04d644b53262b42071430d5de7fb7ec73..7b412622869a55fb059bacdfe5a408139640e75e 100644
--- go-ethereum/accounts/abi/bind/util.go
+++ op-geth/accounts/abi/bind/util.go
@@ -21,10 +21,10 @@ "context"
"errors"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
)
// WaitMined waits for tx to be mined on the blockchain.
diff --git go-ethereum/accounts/abi/error.go op-geth/accounts/abi/error.go
index 8e50112ec5df2c6ba31197bf4cd0cd2682256c52..35c00bdcaaa4f911321a6c811eea76bd317ebdff 100644
--- go-ethereum/accounts/abi/error.go
+++ op-geth/accounts/abi/error.go
@@ -21,8 +21,8 @@ "bytes"
"fmt"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
)
type Error struct {
diff --git go-ethereum/accounts/abi/event.go op-geth/accounts/abi/event.go
index f9457b86afebf21873b35d0a6838802b3b3f2119..f77eb5e29cf462aa1674ecb4aea5c50c98a0f8b9 100644
--- go-ethereum/accounts/abi/event.go
+++ op-geth/accounts/abi/event.go
@@ -20,8 +20,8 @@ import (
"fmt"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
)
// Event is an event potentially triggered by the EVM's LOG mechanism. The Event
diff --git go-ethereum/accounts/abi/method.go op-geth/accounts/abi/method.go
index c5a1a71f475122d748bbcb543321b0e5f5006666..5d47db760f67396a8fee633d5d5c4703815ca5c7 100644
--- go-ethereum/accounts/abi/method.go
+++ op-geth/accounts/abi/method.go
@@ -20,7 +20,7 @@ import (
"fmt"
"strings"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/crypto"
)
// FunctionType represents different types of functions a contract might have.
diff --git go-ethereum/accounts/abi/pack.go op-geth/accounts/abi/pack.go
index beef1fa37fa7157c72f5bf34daadf5aa9e8cb557..638f3cae271abfabb0e713cf2ad2e4ded4fe21b5 100644
--- go-ethereum/accounts/abi/pack.go
+++ op-geth/accounts/abi/pack.go
@@ -22,8 +22,8 @@ "fmt"
"math/big"
"reflect"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
)
// packBytesSlice packs the given bytes as [L, V] as the canonical representation
diff --git go-ethereum/accounts/abi/topics.go op-geth/accounts/abi/topics.go
index 7ce9b7273c47bc18f6613cb6792d1a40438c2a66..75bfe2f0e2583f0905893c0aa622c44170d829fd 100644
--- go-ethereum/accounts/abi/topics.go
+++ op-geth/accounts/abi/topics.go
@@ -23,9 +23,9 @@ "fmt"
"math/big"
"reflect"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
)
// MakeTopics converts a filter query argument list into a filter topic set.
diff --git go-ethereum/accounts/abi/type.go op-geth/accounts/abi/type.go
index 2eee11787fdaacfece6e13319f39d895d1558a44..b3e346b08ac599295579978bfe62e8c0fd590055 100644
--- go-ethereum/accounts/abi/type.go
+++ op-geth/accounts/abi/type.go
@@ -26,7 +26,7 @@ "strings"
"unicode"
"unicode/utf8"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// Type enumerator
diff --git go-ethereum/accounts/abi/unpack.go op-geth/accounts/abi/unpack.go
index 905b5ce629db5684495aa87da39c9cfdee6bc69c..5ae4fc5d87cd1bcc1795ee6c1e7d50daf5bc94d1 100644
--- go-ethereum/accounts/abi/unpack.go
+++ op-geth/accounts/abi/unpack.go
@@ -24,7 +24,7 @@ "math"
"math/big"
"reflect"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
var (
diff --git go-ethereum/accounts/accounts.go op-geth/accounts/accounts.go
index 6c351a9649ea0a286f539d44ce8062b59ff725f3..7027d5e1a5dd2e2deadfa6f574de1175c950e780 100644
--- go-ethereum/accounts/accounts.go
+++ op-geth/accounts/accounts.go
@@ -21,10 +21,10 @@ import (
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/event"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/event"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/accounts/external/backend.go op-geth/accounts/external/backend.go
index 6f1581f9b806deacf12a5667c24feaff003ed2f6..a304eeb8487bec63114b76d9d6fa93da9fd99bba 100644
--- go-ethereum/accounts/external/backend.go
+++ op-geth/accounts/external/backend.go
@@ -22,15 +22,15 @@ "fmt"
"math/big"
"sync"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rpc"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
)
type ExternalBackend struct {
diff --git go-ethereum/accounts/keystore/account_cache.go op-geth/accounts/keystore/account_cache.go
index 4ed1439514e1738d00ee0717e2b926b2be5fa9a1..6a6270c8029b9b9f7d61a45d148395b7bd842d89 100644
--- go-ethereum/accounts/keystore/account_cache.go
+++ op-geth/accounts/keystore/account_cache.go
@@ -28,9 +28,9 @@ "sync"
"time"
mapset "github.com/deckarep/golang-set/v2"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/log"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/accounts/keystore/file_cache.go op-geth/accounts/keystore/file_cache.go
index 63eb8503744f83979b1bd48bd5649ef7208753bc..b9d9b9720969c588d65e6961e06db222f7ca5e92 100644
--- go-ethereum/accounts/keystore/file_cache.go
+++ op-geth/accounts/keystore/file_cache.go
@@ -24,7 +24,7 @@ "sync"
"time"
mapset "github.com/deckarep/golang-set/v2"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
// fileCache is a cache of files seen during scan of keystore.
diff --git go-ethereum/accounts/keystore/key.go op-geth/accounts/keystore/key.go
index 9b2ac147122a9710a48fb7a84068b94a7895060f..d74ec578f191227406feb47efb63777380d01e94 100644
--- go-ethereum/accounts/keystore/key.go
+++ op-geth/accounts/keystore/key.go
@@ -28,10 +28,10 @@ "path/filepath"
"strings"
"time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
"github.com/google/uuid"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
)
const (
diff --git go-ethereum/accounts/keystore/keystore.go op-geth/accounts/keystore/keystore.go
index 0ffcf376a5fdd9bde9b5c193444ed6f67518cf8d..a2f203ddc05c4108aaf1c83ec67a0605e6119b80 100644
--- go-ethereum/accounts/keystore/keystore.go
+++ op-geth/accounts/keystore/keystore.go
@@ -32,11 +32,11 @@ "runtime"
"sync"
"time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/event"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/event"
)
var (
diff --git go-ethereum/accounts/keystore/passphrase.go op-geth/accounts/keystore/passphrase.go
index e7a7f8d0cb0c673f6a893a33019413c6cce2748e..6f32318044bdb792feb410514934acd9be122aec 100644
--- go-ethereum/accounts/keystore/passphrase.go
+++ op-geth/accounts/keystore/passphrase.go
@@ -37,11 +37,11 @@ "io"
"os"
"path/filepath"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
"github.com/google/uuid"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
"golang.org/x/crypto/pbkdf2"
"golang.org/x/crypto/scrypt"
)
@@ -120,7 +120,7 @@ msg := "An error was encountered when saving and verifying the keystore file. \n" +
"This indicates that the keystore is corrupted. \n" +
"The corrupted file is stored at \n%v\n" +
"Please file a ticket at:\n\n" +
- "https://github.com/ethereum/go-ethereum/issues." +
+ "https://github.com/tenderly/op-geth/issues." +
"The error was : %s"
//lint:ignore ST1005 This is a message for the user
return fmt.Errorf(msg, tmpName, err)
diff --git go-ethereum/accounts/keystore/plain.go op-geth/accounts/keystore/plain.go
index f62a133ce16909422f3664a5e64d7e610791cbd1..6e70c649e038919f4256eca6596ff34c99296164 100644
--- go-ethereum/accounts/keystore/plain.go
+++ op-geth/accounts/keystore/plain.go
@@ -22,7 +22,7 @@ "fmt"
"os"
"path/filepath"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
type keyStorePlain struct {
diff --git go-ethereum/accounts/keystore/presale.go op-geth/accounts/keystore/presale.go
index 0664dc2cdd0577d77904c26e7ac4fe3cd64949fe..c3962e319e7a0ecde9a5a44394f1bc7ba2351089 100644
--- go-ethereum/accounts/keystore/presale.go
+++ op-geth/accounts/keystore/presale.go
@@ -25,9 +25,9 @@ "encoding/json"
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/crypto"
"github.com/google/uuid"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/crypto"
"golang.org/x/crypto/pbkdf2"
)
diff --git go-ethereum/accounts/keystore/wallet.go op-geth/accounts/keystore/wallet.go
index 1066095f6d0759e0e67ed2cf7ffd4c5aee21d6b5..d994f5a7e973f354d40fe608d197c880ac99d05c 100644
--- go-ethereum/accounts/keystore/wallet.go
+++ op-geth/accounts/keystore/wallet.go
@@ -19,10 +19,10 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
)
// keystoreWallet implements the accounts.Wallet interface for the original
diff --git go-ethereum/accounts/keystore/watch.go op-geth/accounts/keystore/watch.go
index 1bef321cd1f60966350cd2e8a578c0dbaa17ccc6..ebfbe33bec75af5768ec4260ad6227a58366f642 100644
--- go-ethereum/accounts/keystore/watch.go
+++ op-geth/accounts/keystore/watch.go
@@ -23,8 +23,8 @@ import (
"os"
"time"
- "github.com/ethereum/go-ethereum/log"
"github.com/fsnotify/fsnotify"
+ "github.com/tenderly/op-geth/log"
)
type watcher struct {
diff --git go-ethereum/accounts/manager.go op-geth/accounts/manager.go
index cbe4f7c79d858683ae3759f6b30436d0a8968760..e7723a424dbc0c76fdb762dd6b850ebb1c2c50e0 100644
--- go-ethereum/accounts/manager.go
+++ op-geth/accounts/manager.go
@@ -21,8 +21,8 @@ "reflect"
"sort"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/event"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/event"
)
// managerSubBufferSize determines how many incoming wallet events
diff --git go-ethereum/accounts/scwallet/hub.go op-geth/accounts/scwallet/hub.go
index 5f1f369ca2a024caab5f064aca80da03a8310cf8..91bc3bd9f4e73034b529f5b18fd17f19b0b29e60 100644
--- go-ethereum/accounts/scwallet/hub.go
+++ op-geth/accounts/scwallet/hub.go
@@ -41,11 +41,11 @@ "sort"
"sync"
"time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
pcsc "github.com/gballet/go-libpcsclite"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
)
// Scheme is the URI prefix for smartcard wallets.
diff --git go-ethereum/accounts/scwallet/securechannel.go op-geth/accounts/scwallet/securechannel.go
index bbd8b2264796c403809db9643f2290b62eb40bc1..9cf89e203795d7e99a69aad53266986fac618e2d 100644
--- go-ethereum/accounts/scwallet/securechannel.go
+++ op-geth/accounts/scwallet/securechannel.go
@@ -27,8 +27,8 @@ "crypto/sha512"
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/crypto"
pcsc "github.com/gballet/go-libpcsclite"
+ "github.com/tenderly/op-geth/crypto"
"golang.org/x/crypto/pbkdf2"
"golang.org/x/text/unicode/norm"
)
diff --git go-ethereum/accounts/scwallet/wallet.go op-geth/accounts/scwallet/wallet.go
index f0ca9085b6800260bd889bad5944f5f8a787d3cb..7ce87b2094635e9e3c4384339e7963c35b30f3e0 100644
--- go-ethereum/accounts/scwallet/wallet.go
+++ op-geth/accounts/scwallet/wallet.go
@@ -33,14 +33,14 @@ "strings"
"sync"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
pcsc "github.com/gballet/go-libpcsclite"
"github.com/status-im/keycard-go/derivationpath"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
)
// ErrPairingPasswordNeeded is returned if opening the smart card requires pairing with a pairing
diff --git go-ethereum/accounts/usbwallet/ledger.go op-geth/accounts/usbwallet/ledger.go
index d0cb93e74e00fd1b4fc697cb62ba4abf58d933f6..8ac3e19be10b623980d1f595a3ba57d0ba7966e4 100644
--- go-ethereum/accounts/usbwallet/ledger.go
+++ op-geth/accounts/usbwallet/ledger.go
@@ -28,13 +28,13 @@ "fmt"
"io"
"math/big"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
)
// ledgerOpcode is an enumeration encoding the supported Ledger opcodes.
diff --git go-ethereum/accounts/usbwallet/trezor.go op-geth/accounts/usbwallet/trezor.go
index 9644dc4e02c9c8db1cddcb20cac492c1a9d74963..8614eb6f0054e4d826223e4c92f330ae723050db 100644
--- go-ethereum/accounts/usbwallet/trezor.go
+++ op-geth/accounts/usbwallet/trezor.go
@@ -27,13 +27,13 @@ "fmt"
"io"
"math/big"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/usbwallet/trezor"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
"github.com/golang/protobuf/proto"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/usbwallet/trezor"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
)
// ErrTrezorPINNeeded is returned if opening the trezor requires a PIN code. In
diff --git go-ethereum/accounts/usbwallet/wallet.go op-geth/accounts/usbwallet/wallet.go
index 69083dc8939dec5cd7135914ee8a851e9e0b9f81..be2593f0441439d27439c41ced817f08674a4ceb 100644
--- go-ethereum/accounts/usbwallet/wallet.go
+++ op-geth/accounts/usbwallet/wallet.go
@@ -25,13 +25,13 @@ "math/big"
"sync"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
"github.com/karalabe/usb"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
)
// Maximum time between wallet health checks to detect USB unplugs.
diff --git go-ethereum/beacon/engine/errors.go op-geth/beacon/engine/errors.go
index 62773a0ea9f60a1e87e14746628472784d6eda65..dc9925e8c82d32cf1be563fcdd0e32d66ff020d9 100644
--- go-ethereum/beacon/engine/errors.go
+++ op-geth/beacon/engine/errors.go
@@ -17,8 +17,8 @@
package engine
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/rpc"
)
// EngineAPIError is a standardized error message between consensus and execution
diff --git go-ethereum/beacon/engine/gen_ed.go op-geth/beacon/engine/gen_ed.go
index 6893d64a1626a8e172a80865a5ccec6e4e0f53f6..ee65a2e6f11abdfe970768048e5dcd3cdb0679a9 100644
--- go-ethereum/beacon/engine/gen_ed.go
+++ op-geth/beacon/engine/gen_ed.go
@@ -7,9 +7,9 @@ "encoding/json"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
)
var _ = (*executableDataMarshaling)(nil)
diff --git go-ethereum/beacon/engine/gen_epe.go op-geth/beacon/engine/gen_epe.go
index e69f9a5951a28deeaa9ad51f1b2d9e8733b2feca..0e9477966399d3d71092a9a7a23f2346d5704043 100644
--- go-ethereum/beacon/engine/gen_epe.go
+++ op-geth/beacon/engine/gen_epe.go
@@ -7,7 +7,8 @@ "encoding/json"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var _ = (*executionPayloadEnvelopeMarshaling)(nil)
@@ -15,26 +16,29 @@
// MarshalJSON marshals as JSON.
func (e ExecutionPayloadEnvelope) MarshalJSON() ([]byte, error) {
type ExecutionPayloadEnvelope struct {
- ExecutionPayload *ExecutableData `json:"executionPayload" gencodec:"required"`
- BlockValue *hexutil.Big `json:"blockValue" gencodec:"required"`
- BlobsBundle *BlobsBundleV1 `json:"blobsBundle"`
- Override bool `json:"shouldOverrideBuilder"`
+ ExecutionPayload *ExecutableData `json:"executionPayload" gencodec:"required"`
+ BlockValue *hexutil.Big `json:"blockValue" gencodec:"required"`
+ BlobsBundle *BlobsBundleV1 `json:"blobsBundle"`
+ Override bool `json:"shouldOverrideBuilder"`
+ ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot,omitempty"`
}
var enc ExecutionPayloadEnvelope
enc.ExecutionPayload = e.ExecutionPayload
enc.BlockValue = (*hexutil.Big)(e.BlockValue)
enc.BlobsBundle = e.BlobsBundle
enc.Override = e.Override
+ enc.ParentBeaconBlockRoot = e.ParentBeaconBlockRoot
return json.Marshal(&enc)
}
// UnmarshalJSON unmarshals from JSON.
func (e *ExecutionPayloadEnvelope) UnmarshalJSON(input []byte) error {
type ExecutionPayloadEnvelope struct {
- ExecutionPayload *ExecutableData `json:"executionPayload" gencodec:"required"`
- BlockValue *hexutil.Big `json:"blockValue" gencodec:"required"`
- BlobsBundle *BlobsBundleV1 `json:"blobsBundle"`
- Override *bool `json:"shouldOverrideBuilder"`
+ ExecutionPayload *ExecutableData `json:"executionPayload" gencodec:"required"`
+ BlockValue *hexutil.Big `json:"blockValue" gencodec:"required"`
+ BlobsBundle *BlobsBundleV1 `json:"blobsBundle"`
+ Override *bool `json:"shouldOverrideBuilder"`
+ ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot,omitempty"`
}
var dec ExecutionPayloadEnvelope
if err := json.Unmarshal(input, &dec); err != nil {
@@ -53,6 +57,9 @@ e.BlobsBundle = dec.BlobsBundle
}
if dec.Override != nil {
e.Override = *dec.Override
+ }
+ if dec.ParentBeaconBlockRoot != nil {
+ e.ParentBeaconBlockRoot = dec.ParentBeaconBlockRoot
}
return nil
}
diff --git go-ethereum/beacon/light/canonical.go op-geth/beacon/light/canonical.go
index b5371493b4c96058027308ab417d68751bcc8372..14e4a78cf5b3eaa87c78d718012a3d9699011f2d 100644
--- go-ethereum/beacon/light/canonical.go
+++ op-geth/beacon/light/canonical.go
@@ -20,10 +20,10 @@ import (
"encoding/binary"
"fmt"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
)
// canonicalStore stores instances of the given type in a database and caches
diff --git go-ethereum/beacon/light/committee_chain.go op-geth/beacon/light/committee_chain.go
index d707f8cc34da63522667adfd144690e948e4717b..07e79eb8c93d850d2fd7bfdf57f81106b27a4fd4 100644
--- go-ethereum/beacon/light/committee_chain.go
+++ op-geth/beacon/light/committee_chain.go
@@ -23,14 +23,14 @@ "math"
"sync"
"time"
- "github.com/ethereum/go-ethereum/beacon/params"
- "github.com/ethereum/go-ethereum/beacon/types"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/beacon/params"
+ "github.com/tenderly/op-geth/beacon/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
)
var (
diff --git go-ethereum/beacon/light/test_helpers.go op-geth/beacon/light/test_helpers.go
index f537d963a667ecc738e9a74fdf2491ab17494306..258ae497a64b9aa635fcae8b133fe43beec73866 100644
--- go-ethereum/beacon/light/test_helpers.go
+++ op-geth/beacon/light/test_helpers.go
@@ -21,10 +21,10 @@ "crypto/rand"
"crypto/sha256"
mrand "math/rand"
- "github.com/ethereum/go-ethereum/beacon/merkle"
- "github.com/ethereum/go-ethereum/beacon/params"
- "github.com/ethereum/go-ethereum/beacon/types"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/beacon/merkle"
+ "github.com/tenderly/op-geth/beacon/params"
+ "github.com/tenderly/op-geth/beacon/types"
+ "github.com/tenderly/op-geth/common"
)
func GenerateTestCommittee() *types.SerializedSyncCommittee {
diff --git go-ethereum/beacon/merkle/merkle.go op-geth/beacon/merkle/merkle.go
index 30896f9b017db59734eabfc232e11c497ac0fcd4..5e26290a092f03ea25c748d761b3c257437595f7 100644
--- go-ethereum/beacon/merkle/merkle.go
+++ op-geth/beacon/merkle/merkle.go
@@ -22,8 +22,8 @@ "crypto/sha256"
"errors"
"reflect"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
// Value represents either a 32 byte leaf value or hash node in a binary merkle tree/partial proof.
diff --git go-ethereum/beacon/types/committee.go op-geth/beacon/types/committee.go
index 5f89c27554aca5d0b1ea1b6465acf2e90b8fa12a..76612412c18c9462c7d52d679071222032c62c6d 100644
--- go-ethereum/beacon/types/committee.go
+++ op-geth/beacon/types/committee.go
@@ -22,10 +22,10 @@ "encoding/json"
"fmt"
"math/bits"
- "github.com/ethereum/go-ethereum/beacon/params"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
bls "github.com/protolambda/bls12-381-util"
+ "github.com/tenderly/op-geth/beacon/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
// SerializedSyncCommitteeSize is the size of the sync committee plus the
diff --git go-ethereum/beacon/types/config.go op-geth/beacon/types/config.go
index 8cb8808b6f02e4bc056d72335ba8fb06f354509c..94a10427e934094dcd4109d295da155747ba5eb8 100644
--- go-ethereum/beacon/types/config.go
+++ op-geth/beacon/types/config.go
@@ -24,9 +24,9 @@ "sort"
"strconv"
"strings"
- "github.com/ethereum/go-ethereum/beacon/merkle"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/beacon/merkle"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
"gopkg.in/yaml.v3"
)
diff --git go-ethereum/beacon/types/gen_header_json.go op-geth/beacon/types/gen_header_json.go
index 9b3ffea06fcf17b1f7a82659017878815f11fce2..694dd6ab2ecb05f54a1795670b3b4a240e38bae8 100644
--- go-ethereum/beacon/types/gen_header_json.go
+++ op-geth/beacon/types/gen_header_json.go
@@ -6,7 +6,7 @@ import (
"encoding/json"
"errors"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
var _ = (*headerMarshaling)(nil)
diff --git go-ethereum/beacon/types/gen_syncaggregate_json.go op-geth/beacon/types/gen_syncaggregate_json.go
index 1547ec5f01c7d8ecc979f104ebf849f5153fac12..3b87dd8c09543c585efd8bb1fcafde2bdec8db0a 100644
--- go-ethereum/beacon/types/gen_syncaggregate_json.go
+++ op-geth/beacon/types/gen_syncaggregate_json.go
@@ -6,7 +6,7 @@ import (
"encoding/json"
"errors"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var _ = (*syncAggregateMarshaling)(nil)
diff --git go-ethereum/beacon/types/header.go op-geth/beacon/types/header.go
index 2ddc4575f175520ae2d3a94a85a18541757f088c..3a8616dab393f9fa77892c08883bb20acf907b91 100644
--- go-ethereum/beacon/types/header.go
+++ op-geth/beacon/types/header.go
@@ -21,9 +21,9 @@ import (
"crypto/sha256"
"encoding/binary"
- "github.com/ethereum/go-ethereum/beacon/merkle"
- "github.com/ethereum/go-ethereum/beacon/params"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/beacon/merkle"
+ "github.com/tenderly/op-geth/beacon/params"
+ "github.com/tenderly/op-geth/common"
)
//go:generate go run github.com/fjl/gencodec -type Header -field-override headerMarshaling -out gen_header_json.go
diff --git go-ethereum/beacon/types/light_sync.go op-geth/beacon/types/light_sync.go
index 3284081e4d490be38824902799a099e22909242f..2c93903b483d0b2d54c709efc9b3ebf1cbb09f32 100644
--- go-ethereum/beacon/types/light_sync.go
+++ op-geth/beacon/types/light_sync.go
@@ -20,9 +20,9 @@ import (
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/beacon/merkle"
- "github.com/ethereum/go-ethereum/beacon/params"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/beacon/merkle"
+ "github.com/tenderly/op-geth/beacon/params"
+ "github.com/tenderly/op-geth/common"
)
// BootstrapData contains a sync committee where light sync can be started,
diff --git go-ethereum/build/deb/ethereum/deb.control op-geth/build/deb/ethereum/deb.control
index 3b759f2d042bbf20bb51526587ddf1155ce838fb..56b28baa5326dba4ee82224751bdb56eeb7af0ff 100644
--- go-ethereum/build/deb/ethereum/deb.control
+++ op-geth/build/deb/ethereum/deb.control
@@ -5,8 +5,8 @@ Maintainer: {{.Author}}
Build-Depends: debhelper (>= 8.0.0), {{.GoBootPackage}}
Standards-Version: 3.9.5
Homepage: https://ethereum.org
-Vcs-Git: https://github.com/ethereum/go-ethereum.git
-Vcs-Browser: https://github.com/ethereum/go-ethereum
+Vcs-Git: https://github.com/tenderly/op-geth.git
+Vcs-Browser: https://github.com/tenderly/op-geth
Package: {{.Name}}
Architecture: any
diff --git go-ethereum/build/nsis.install.nsh op-geth/build/nsis.install.nsh
index 9b73148a4497d4f4be85269a7c57621cb462857b..6e56b30a6abd32f6eb77c10a74197b1d5086d319 100644
--- go-ethereum/build/nsis.install.nsh
+++ op-geth/build/nsis.install.nsh
@@ -3,9 +3,9 @@ InstallDir "$InstDir"
OutFile "${OUTPUTFILE}" # set through command line arguments
# Links for "Add/Remove Programs"
-!define HELPURL "https://github.com/ethereum/go-ethereum/issues"
-!define UPDATEURL "https://github.com/ethereum/go-ethereum/releases"
-!define ABOUTURL "https://github.com/ethereum/go-ethereum#ethereum-go"
+!define HELPURL "https://github.com/tenderly/op-geth/issues"
+!define UPDATEURL "https://github.com/tenderly/op-geth/releases"
+!define ABOUTURL "https://github.com/tenderly/op-geth#ethereum-go"
!define /date NOW "%Y%m%d"
PageEx license
diff --git go-ethereum/build/update-license.go op-geth/build/update-license.go
index 70e2de06c776faebf55177cf4f154f19433110cf..e747705d45c88d651ffee4619cfb565ac22c0421 100644
--- go-ethereum/build/update-license.go
+++ op-geth/build/update-license.go
@@ -79,7 +79,7 @@ "signer/rules/deps",
"internal/reexec",
// skip special licenses
- "crypto/secp256k1", // Relicensed to BSD-3 via https://github.com/ethereum/go-ethereum/pull/17225
+ "crypto/secp256k1", // Relicensed to BSD-3 via https://github.com/tenderly/op-geth/pull/17225
}
// paths with this prefix are licensed as GPL. all other files are LGPL.
diff --git go-ethereum/cmd/abidump/main.go op-geth/cmd/abidump/main.go
index ae1ac6413910ee0216e561ee9ed5651f5f2e7fa7..c1fb9e598feb8e972fec2a9217fe07ca5e26b058 100644
--- go-ethereum/cmd/abidump/main.go
+++ op-geth/cmd/abidump/main.go
@@ -23,8 +23,8 @@ "fmt"
"os"
"strings"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
- "github.com/ethereum/go-ethereum/signer/fourbyte"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
+ "github.com/tenderly/op-geth/signer/fourbyte"
)
func init() {
diff --git go-ethereum/cmd/abigen/main.go op-geth/cmd/abigen/main.go
index 0149dec5277230dd51bbb7a0de8aaab965e859dd..5d2baf5285ebca14697f3a105f730f2c1ffb2353 100644
--- go-ethereum/cmd/abigen/main.go
+++ op-geth/cmd/abigen/main.go
@@ -24,12 +24,12 @@ "os"
"regexp"
"strings"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/common/compiler"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/accounts/abi/bind"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/common/compiler"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/log"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/bootnode/main.go op-geth/cmd/bootnode/main.go
index 350b85df1e60c33fa8825ee20fd5f07cbecd424f..442bc660549d8e81f0d93fb1992ae070c97cbe10 100644
--- go-ethereum/cmd/bootnode/main.go
+++ op-geth/cmd/bootnode/main.go
@@ -25,13 +25,13 @@ "net"
"os"
"time"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/discover"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/nat"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/discover"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/nat"
+ "github.com/tenderly/op-geth/p2p/netutil"
)
func main() {
diff --git go-ethereum/cmd/clef/main.go op-geth/cmd/clef/main.go
index f9b00e4a12a0ef7d378baf71e2bbe205ced8b5d8..e8f545d23d582d723761a4bcb6b4be2e839bf18c 100644
--- go-ethereum/cmd/clef/main.go
+++ op-geth/cmd/clef/main.go
@@ -35,27 +35,27 @@ "runtime"
"strings"
"time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/signer/core"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
- "github.com/ethereum/go-ethereum/signer/fourbyte"
- "github.com/ethereum/go-ethereum/signer/rules"
- "github.com/ethereum/go-ethereum/signer/storage"
"github.com/mattn/go-colorable"
"github.com/mattn/go-isatty"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/rpc"
+ "github.com/tenderly/op-geth/signer/core"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
+ "github.com/tenderly/op-geth/signer/fourbyte"
+ "github.com/tenderly/op-geth/signer/rules"
+ "github.com/tenderly/op-geth/signer/storage"
"github.com/urfave/cli/v2"
)
@@ -873,7 +873,7 @@ return fmt.Errorf("failed stat on %s: %v", filename, err)
}
// Check the unix permission bits
// However, on windows, we cannot use the unix perm-bits, see
- // https://github.com/ethereum/go-ethereum/issues/20123
+ // https://github.com/tenderly/op-geth/issues/20123
if runtime.GOOS != "windows" && info.Mode().Perm()&0377 != 0 {
return fmt.Errorf("file (%v) has insecure file permissions (%v)", filename, info.Mode().String())
}
diff --git go-ethereum/cmd/clef/tutorial.md op-geth/cmd/clef/tutorial.md
index 3ea662b5d4c70643759bc653da10ccb86d16e89e..9c3dbb03de8fc5f1ac343b89a01ccdc1bc565ab5 100644
--- go-ethereum/cmd/clef/tutorial.md
+++ op-geth/cmd/clef/tutorial.md
@@ -100,9 +100,9 @@
{"jsonrpc":"2.0","id":1,"error":{"code":-32000,"message":"Request denied"}}
```
-Apart from listing accounts, you can also *request* creating a new account; signing transactions and data; and recovering signatures. You can find the available methods in the Clef [External API Spec](https://github.com/ethereum/go-ethereum/tree/master/cmd/clef#external-api-1) and the [External API Changelog](https://github.com/ethereum/go-ethereum/blob/master/cmd/clef/extapi_changelog.md).
+Apart from listing accounts, you can also *request* creating a new account; signing transactions and data; and recovering signatures. You can find the available methods in the Clef [External API Spec](https://github.com/tenderly/op-geth/tree/master/cmd/clef#external-api-1) and the [External API Changelog](https://github.com/tenderly/op-geth/blob/master/cmd/clef/extapi_changelog.md).
-*Note, the number of things you can do from the External API is deliberately small, since we want to limit the power of remote calls by as much as possible! Clef has an [Internal API](https://github.com/ethereum/go-ethereum/tree/master/cmd/clef#ui-api-1) too for the UI (User Interface) which is much richer and can support custom interfaces on top. But that's out of scope here.*
+*Note, the number of things you can do from the External API is deliberately small, since we want to limit the power of remote calls by as much as possible! Clef has an [Internal API](https://github.com/tenderly/op-geth/tree/master/cmd/clef#ui-api-1) too for the UI (User Interface) which is much richer and can support custom interfaces on top. But that's out of scope here.*
## Automatic rules
@@ -288,7 +288,7 @@ t=2019-07-01T15:52:23+0300 lvl=info msg=SignData api=signer type=request metadata="{\"remote\":\"NA\",\"local\":\"NA\",\"scheme\":\"NA\",\"User-Agent\":\"\",\"Origin\":\"\"}" addr="0xd9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f3 [chksum INVALID]" data=0x2020626f6e6b2062617a2067617a0a content-type=data/plain
t=2019-07-01T15:52:23+0300 lvl=info msg=SignData api=signer type=response data= error="Request denied"
```
-For more details on writing automatic rules, please see the [rules spec](https://github.com/ethereum/go-ethereum/blob/master/cmd/clef/rules.md).
+For more details on writing automatic rules, please see the [rules spec](https://github.com/tenderly/op-geth/blob/master/cmd/clef/rules.md).
## Geth integration
diff --git go-ethereum/cmd/devp2p/crawl.go op-geth/cmd/devp2p/crawl.go
index 4288a5feb897ba725fac3d1789f4ce2b1c92d319..9c6d2840d9268a1b9fa4bccddbdf79bf27b94b95 100644
--- go-ethereum/cmd/devp2p/crawl.go
+++ op-geth/cmd/devp2p/crawl.go
@@ -22,8 +22,8 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/enode"
)
type crawler struct {
diff --git go-ethereum/cmd/devp2p/discv4cmd.go op-geth/cmd/devp2p/discv4cmd.go
index 45bcdcd3674b1bd1dd24ff0dacaf485b58034f6e..1fb821ec8d744df3b58a21c3a269114c321dc8a6 100644
--- go-ethereum/cmd/devp2p/discv4cmd.go
+++ op-geth/cmd/devp2p/discv4cmd.go
@@ -24,13 +24,13 @@ "strconv"
"strings"
"time"
- "github.com/ethereum/go-ethereum/cmd/devp2p/internal/v4test"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/p2p/discover"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/cmd/devp2p/internal/v4test"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/p2p/discover"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/params"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/devp2p/discv5cmd.go op-geth/cmd/devp2p/discv5cmd.go
index 0dac94526971f9e230fb7a909a1418667a3e200b..74dca8b5c63ae95caef2b411660ac103c2f5449f 100644
--- go-ethereum/cmd/devp2p/discv5cmd.go
+++ op-geth/cmd/devp2p/discv5cmd.go
@@ -21,10 +21,10 @@ "errors"
"fmt"
"time"
- "github.com/ethereum/go-ethereum/cmd/devp2p/internal/v5test"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/p2p/discover"
+ "github.com/tenderly/op-geth/cmd/devp2p/internal/v5test"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/p2p/discover"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/devp2p/dns_cloudflare.go op-geth/cmd/devp2p/dns_cloudflare.go
index a3cc69cf1925450c9df7c10415a64e1c16287a5d..3a14fe19969ebdfb804239ca29074e29a24e0199 100644
--- go-ethereum/cmd/devp2p/dns_cloudflare.go
+++ op-geth/cmd/devp2p/dns_cloudflare.go
@@ -23,8 +23,8 @@ "fmt"
"strings"
"github.com/cloudflare/cloudflare-go"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/dnsdisc"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/dnsdisc"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/devp2p/dns_route53.go op-geth/cmd/devp2p/dns_route53.go
index 21a32f9414e4d3cb0123eb53282d30409faafb77..e8462e636e80207cc50d4f14a07592f59da782a0 100644
--- go-ethereum/cmd/devp2p/dns_route53.go
+++ op-geth/cmd/devp2p/dns_route53.go
@@ -29,8 +29,8 @@ "github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/credentials"
"github.com/aws/aws-sdk-go-v2/service/route53"
"github.com/aws/aws-sdk-go-v2/service/route53/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/dnsdisc"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/dnsdisc"
"github.com/urfave/cli/v2"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/cmd/devp2p/dnscmd.go op-geth/cmd/devp2p/dnscmd.go
index 0fce7b10308b1b44db606888f4465e7cc365eb7f..4ec2aa68ea04f7f1e6d26ae8946afe65c3ed1a03 100644
--- go-ethereum/cmd/devp2p/dnscmd.go
+++ op-geth/cmd/devp2p/dnscmd.go
@@ -25,11 +25,11 @@ "os"
"path/filepath"
"time"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/console/prompt"
- "github.com/ethereum/go-ethereum/p2p/dnsdisc"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/console/prompt"
+ "github.com/tenderly/op-geth/p2p/dnsdisc"
+ "github.com/tenderly/op-geth/p2p/enode"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/devp2p/enrcmd.go op-geth/cmd/devp2p/enrcmd.go
index c5a97c8411fdad806a7ab18ef07cf404a7ae9b76..3dfc3238cad3b3cb4db8361fa481608ce4f5f226 100644
--- go-ethereum/cmd/devp2p/enrcmd.go
+++ op-geth/cmd/devp2p/enrcmd.go
@@ -28,9 +28,9 @@ "os"
"strconv"
"strings"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/devp2p/internal/ethtest/chain.go op-geth/cmd/devp2p/internal/ethtest/chain.go
index e8b3725b17a5cdb858938bbab700cb3ca70fc2b5..444323edaeaf75dbb1a8669f6c083b99c0f605e5 100644
--- go-ethereum/cmd/devp2p/internal/ethtest/chain.go
+++ op-geth/cmd/devp2p/internal/ethtest/chain.go
@@ -30,16 +30,16 @@ "path"
"sort"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/forkid"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/forkid"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/cmd/devp2p/internal/ethtest/conn.go op-geth/cmd/devp2p/internal/ethtest/conn.go
index ba3c0585fde98f74597268bba42ee6b43022e8c0..9119f1cf9a28b313f8dded807ad5609358f9c987 100644
--- go-ethereum/cmd/devp2p/internal/ethtest/conn.go
+++ op-geth/cmd/devp2p/internal/ethtest/conn.go
@@ -25,12 +25,12 @@ "reflect"
"time"
"github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/eth/protocols/snap"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/rlpx"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/eth/protocols/snap"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/rlpx"
+ "github.com/tenderly/op-geth/rlp"
)
var (
diff --git go-ethereum/cmd/devp2p/internal/ethtest/engine.go op-geth/cmd/devp2p/internal/ethtest/engine.go
index ea4fc76e6ff79f69c127bfe9a5ea955385aa7dc3..c2ae7767dbc38b76436746ccf0e3d535a40d8ae5 100644
--- go-ethereum/cmd/devp2p/internal/ethtest/engine.go
+++ op-geth/cmd/devp2p/internal/ethtest/engine.go
@@ -25,8 +25,8 @@ "os"
"path"
"time"
- "github.com/ethereum/go-ethereum/common"
"github.com/golang-jwt/jwt/v4"
+ "github.com/tenderly/op-geth/common"
)
// EngineClient is a wrapper around engine-related data.
diff --git go-ethereum/cmd/devp2p/internal/ethtest/protocol.go op-geth/cmd/devp2p/internal/ethtest/protocol.go
index f5f5f7e4897386820a517af3c6b58b102dd15ded..626a30fe5889e1d4cb2dadc87d54d84e38357b8d 100644
--- go-ethereum/cmd/devp2p/internal/ethtest/protocol.go
+++ op-geth/cmd/devp2p/internal/ethtest/protocol.go
@@ -16,8 +16,8 @@ // along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
package ethtest
import (
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/rlp"
)
// Unexported devp2p message codes from p2p/peer.go.
diff --git go-ethereum/cmd/devp2p/internal/ethtest/snap.go op-geth/cmd/devp2p/internal/ethtest/snap.go
index 64e063358545ee8fd2cb0fbf9d8c6ae2ead74f0c..e2908031d5b79c41c4b1fc0560012c1b5119590b 100644
--- go-ethereum/cmd/devp2p/internal/ethtest/snap.go
+++ op-geth/cmd/devp2p/internal/ethtest/snap.go
@@ -24,14 +24,14 @@ "math/big"
"math/rand"
"reflect"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/protocols/snap"
- "github.com/ethereum/go-ethereum/internal/utesting"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/protocols/snap"
+ "github.com/tenderly/op-geth/internal/utesting"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/trie/trienode"
"golang.org/x/crypto/sha3"
)
@@ -470,13 +470,13 @@ {
desc: `Here we request state roots as code hashes. The server should deliver an empty response with no items.`,
nBytes: 10000,
hashes: []common.Hash{genesisRoot, headRoot},
- expHashes: 0,
+ expHashes: 1, // 32-byte keys are detected as code, even if not code (like genesis hash), in legacy lookups.
},
{
desc: `Here we request the genesis state root (which is not an existing code hash) two times. The server should deliver an empty response with no items.`,
nBytes: 10000,
hashes: []common.Hash{genesisRoot, genesisRoot},
- expHashes: 0,
+ expHashes: 2, // 32-byte keys are detected as code, even if not code (like genesis hash), in legacy lookups.
},
// Empties
{
diff --git go-ethereum/cmd/devp2p/internal/ethtest/suite.go op-geth/cmd/devp2p/internal/ethtest/suite.go
index d9efe2624432f2a4536d550686ae902a1769dd4f..abf283f205435cd7d2ac69642d062c529e72b2b7 100644
--- go-ethereum/cmd/devp2p/internal/ethtest/suite.go
+++ op-geth/cmd/devp2p/internal/ethtest/suite.go
@@ -21,16 +21,16 @@ "crypto/rand"
"math/big"
"reflect"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/internal/utesting"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/internal/utesting"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// Suite represents a structure used to test a node's conformance
diff --git go-ethereum/cmd/devp2p/internal/ethtest/transaction.go op-geth/cmd/devp2p/internal/ethtest/transaction.go
index 80b5d80745eca48eef7d53be017b1f4eab534b37..687cc61cca7572d406ff68ec8a71470147628538 100644
--- go-ethereum/cmd/devp2p/internal/ethtest/transaction.go
+++ op-geth/cmd/devp2p/internal/ethtest/transaction.go
@@ -22,10 +22,10 @@ "fmt"
"os"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/internal/utesting"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/internal/utesting"
)
// sendTxs sends the given transactions to the node and
diff --git go-ethereum/cmd/devp2p/internal/v4test/discv4tests.go op-geth/cmd/devp2p/internal/v4test/discv4tests.go
index ca556851b467a9775af7d1d3510211c4d88432a5..342d7203d8c11e6fdac287878a75d1f46058503e 100644
--- go-ethereum/cmd/devp2p/internal/v4test/discv4tests.go
+++ op-geth/cmd/devp2p/internal/v4test/discv4tests.go
@@ -24,9 +24,9 @@ "fmt"
"net"
"time"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/utesting"
- "github.com/ethereum/go-ethereum/p2p/discover/v4wire"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/utesting"
+ "github.com/tenderly/op-geth/p2p/discover/v4wire"
)
const (
diff --git go-ethereum/cmd/devp2p/internal/v4test/framework.go op-geth/cmd/devp2p/internal/v4test/framework.go
index 92865941810bd24400962400277af2784cc2616e..d97e86a567d669809d063f8a4315b95131a52664 100644
--- go-ethereum/cmd/devp2p/internal/v4test/framework.go
+++ op-geth/cmd/devp2p/internal/v4test/framework.go
@@ -22,9 +22,9 @@ "fmt"
"net"
"time"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/discover/v4wire"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/discover/v4wire"
+ "github.com/tenderly/op-geth/p2p/enode"
)
const waitTime = 300 * time.Millisecond
diff --git go-ethereum/cmd/devp2p/internal/v5test/discv5tests.go op-geth/cmd/devp2p/internal/v5test/discv5tests.go
index 56624a0ca8e9a0f06f18c8d28b8fee8620ac7832..8b98bd28b00ca993b6cd3f5b64d51e7fa751be68 100644
--- go-ethereum/cmd/devp2p/internal/v5test/discv5tests.go
+++ op-geth/cmd/devp2p/internal/v5test/discv5tests.go
@@ -22,10 +22,10 @@ "net"
"sync"
"time"
- "github.com/ethereum/go-ethereum/internal/utesting"
- "github.com/ethereum/go-ethereum/p2p/discover/v5wire"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/internal/utesting"
+ "github.com/tenderly/op-geth/p2p/discover/v5wire"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/netutil"
)
// Suite is the discv5 test suite.
diff --git go-ethereum/cmd/devp2p/internal/v5test/framework.go op-geth/cmd/devp2p/internal/v5test/framework.go
index 10856a50bcf91c435557bfae6266e0b0a747a333..dbbf48811e0feb4bc3ac7fc1f92d77588785722f 100644
--- go-ethereum/cmd/devp2p/internal/v5test/framework.go
+++ op-geth/cmd/devp2p/internal/v5test/framework.go
@@ -24,11 +24,11 @@ "fmt"
"net"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/discover/v5wire"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/discover/v5wire"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
)
// readError represents an error during packet reading.
diff --git go-ethereum/cmd/devp2p/keycmd.go op-geth/cmd/devp2p/keycmd.go
index 98d7bd76aee115e5f8285f8d3532a4d4a06e1e58..e17f789caebefb7362499c78f375540beed1b600 100644
--- go-ethereum/cmd/devp2p/keycmd.go
+++ op-geth/cmd/devp2p/keycmd.go
@@ -21,9 +21,9 @@ "errors"
"fmt"
"net"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/devp2p/main.go op-geth/cmd/devp2p/main.go
index 8461a8b9b5e257c8cecbad8e99ee7801e38312b7..dc1d8145824a108f75cb62a6dbe45aa7f6ef69ae 100644
--- go-ethereum/cmd/devp2p/main.go
+++ op-geth/cmd/devp2p/main.go
@@ -20,9 +20,9 @@ import (
"fmt"
"os"
- "github.com/ethereum/go-ethereum/internal/debug"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/internal/debug"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/p2p/enode"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/devp2p/nodeset.go op-geth/cmd/devp2p/nodeset.go
index 7360dc5bcfd9f41777a03de2f7ee94749bc070d3..bfd2e6ee806ce9d0684dab81fe27cda1efe67042 100644
--- go-ethereum/cmd/devp2p/nodeset.go
+++ op-geth/cmd/devp2p/nodeset.go
@@ -23,8 +23,8 @@ "fmt"
"os"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/p2p/enode"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/cmd/devp2p/nodesetcmd.go op-geth/cmd/devp2p/nodesetcmd.go
index 6fbc185ad8adaafac8c1515a7120f9e5125f2624..d6277b74c9b709624344c07773e63f256b57fcb2 100644
--- go-ethereum/cmd/devp2p/nodesetcmd.go
+++ op-geth/cmd/devp2p/nodesetcmd.go
@@ -25,11 +25,11 @@ "strconv"
"strings"
"time"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/forkid"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/forkid"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/devp2p/rlpxcmd.go op-geth/cmd/devp2p/rlpxcmd.go
index aa7d065818d96291fdb2c9b14e3e4d4e12862e93..9f2301607244ea0fd50c1e8f33a62a6e688aff2e 100644
--- go-ethereum/cmd/devp2p/rlpxcmd.go
+++ op-geth/cmd/devp2p/rlpxcmd.go
@@ -21,12 +21,12 @@ "errors"
"fmt"
"net"
- "github.com/ethereum/go-ethereum/cmd/devp2p/internal/ethtest"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/rlpx"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/cmd/devp2p/internal/ethtest"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/rlpx"
+ "github.com/tenderly/op-geth/rlp"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/devp2p/runtest.go op-geth/cmd/devp2p/runtest.go
index 7e3723c641dc44a535f947a8a044ce6ca33dab73..3c8df409d2e48c30f2ec75b7d0d0dfd509751cb5 100644
--- go-ethereum/cmd/devp2p/runtest.go
+++ op-geth/cmd/devp2p/runtest.go
@@ -19,10 +19,10 @@
import (
"os"
- "github.com/ethereum/go-ethereum/cmd/devp2p/internal/v4test"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/internal/utesting"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/cmd/devp2p/internal/v4test"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/internal/utesting"
+ "github.com/tenderly/op-geth/log"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/era/main.go op-geth/cmd/era/main.go
index e27d8ccec60540cf4e7cc041a84a3b19abbf65f7..0a71edb3216f23ee4e724629619bf0faee24965b 100644
--- go-ethereum/cmd/era/main.go
+++ op-geth/cmd/era/main.go
@@ -26,13 +26,14 @@ "strconv"
"strings"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/internal/era"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/internal/era"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie"
"github.com/urfave/cli/v2"
)
@@ -121,7 +122,11 @@ if err != nil {
return fmt.Errorf("error reading block %d: %w", num, err)
}
// Convert block to JSON and print.
- val := ethapi.RPCMarshalBlock(block, ctx.Bool(txsFlag.Name), ctx.Bool(txsFlag.Name), params.MainnetChainConfig)
+ // TODO: without a proper Eth API Backend, this tool isn't expected to function correctly
+ val, err := ethapi.RPCMarshalBlock(ctx.Context, block, ctx.Bool(txsFlag.Name), ctx.Bool(txsFlag.Name), params.MainnetChainConfig, ð.EthAPIBackend{})
+ if err != nil {
+ return fmt.Errorf("error marshaling block: %w", err)
+ }
b, err := json.MarshalIndent(val, "", " ")
if err != nil {
return fmt.Errorf("error marshaling json: %w", err)
diff --git go-ethereum/cmd/ethkey/changepassword.go op-geth/cmd/ethkey/changepassword.go
index 4298e2b834079829e07daa696495c30957d3135e..83d6b4c0d15c28cb4213a565c8789f3e19de031f 100644
--- go-ethereum/cmd/ethkey/changepassword.go
+++ op-geth/cmd/ethkey/changepassword.go
@@ -21,8 +21,8 @@ "fmt"
"os"
"strings"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/cmd/utils"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/cmd/utils"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/ethkey/generate.go op-geth/cmd/ethkey/generate.go
index 60d8b3c7795bf13ef1759e35d740ca89adce3291..af659ae76e3c3ab92769cdc598e5249cc505093d 100644
--- go-ethereum/cmd/ethkey/generate.go
+++ op-geth/cmd/ethkey/generate.go
@@ -22,10 +22,10 @@ "fmt"
"os"
"path/filepath"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/crypto"
"github.com/google/uuid"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/crypto"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/ethkey/inspect.go op-geth/cmd/ethkey/inspect.go
index 29b1c13e859b966886eeaad5f040f7987b01c81a..c514159576480a50f78af4aae7494e6a9c2d9df5 100644
--- go-ethereum/cmd/ethkey/inspect.go
+++ op-geth/cmd/ethkey/inspect.go
@@ -21,9 +21,9 @@ "encoding/hex"
"fmt"
"os"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/crypto"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/ethkey/main.go op-geth/cmd/ethkey/main.go
index 25c0d104f61e92c0f501e076f783540bc0dc17e6..ba73e34930ad6c550c6f530ae7ad2868508805b2 100644
--- go-ethereum/cmd/ethkey/main.go
+++ op-geth/cmd/ethkey/main.go
@@ -20,7 +20,7 @@ import (
"fmt"
"os"
- "github.com/ethereum/go-ethereum/internal/flags"
+ "github.com/tenderly/op-geth/internal/flags"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/ethkey/message.go op-geth/cmd/ethkey/message.go
index 6b8dec03cd6703227f4f50173f57783df6f9aafd..1902abd8ab7a526f17e125d001b62d5582c7d034 100644
--- go-ethereum/cmd/ethkey/message.go
+++ op-geth/cmd/ethkey/message.go
@@ -21,11 +21,11 @@ "encoding/hex"
"fmt"
"os"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/ethkey/utils.go op-geth/cmd/ethkey/utils.go
index 2821145089ec6d1e849abde4b39d61e2179d30f3..9d5518a6c147d9ec61dc73165a3963cc81a2034f 100644
--- go-ethereum/cmd/ethkey/utils.go
+++ op-geth/cmd/ethkey/utils.go
@@ -22,7 +22,7 @@ "fmt"
"os"
"strings"
- "github.com/ethereum/go-ethereum/cmd/utils"
+ "github.com/tenderly/op-geth/cmd/utils"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/evm/blockrunner.go op-geth/cmd/evm/blockrunner.go
index c5d836e0ea6123bbed284dcf020dc7320dda40fa..89970e95a4813e10d5db3d6cf9bc5868b2910510 100644
--- go-ethereum/cmd/evm/blockrunner.go
+++ op-geth/cmd/evm/blockrunner.go
@@ -24,11 +24,11 @@ "os"
"regexp"
"sort"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers/logger"
- "github.com/ethereum/go-ethereum/tests"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers/logger"
+ "github.com/tenderly/op-geth/tests"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/evm/compiler.go op-geth/cmd/evm/compiler.go
index c071834b59411f6b5029ee2a8d72044006851236..cdd366c650950ff8c70858ff4564ed1a2ce4f8c6 100644
--- go-ethereum/cmd/evm/compiler.go
+++ op-geth/cmd/evm/compiler.go
@@ -21,7 +21,7 @@ "errors"
"fmt"
"os"
- "github.com/ethereum/go-ethereum/cmd/evm/internal/compiler"
+ "github.com/tenderly/op-geth/cmd/evm/internal/compiler"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/evm/disasm.go op-geth/cmd/evm/disasm.go
index b1f35cbaf5128caa15450463cc69c78487ffa002..048eae903041886b36db2e784dc1b4af523cf2ce 100644
--- go-ethereum/cmd/evm/disasm.go
+++ op-geth/cmd/evm/disasm.go
@@ -22,7 +22,7 @@ "fmt"
"os"
"strings"
- "github.com/ethereum/go-ethereum/core/asm"
+ "github.com/tenderly/op-geth/core/asm"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/evm/internal/compiler/compiler.go op-geth/cmd/evm/internal/compiler/compiler.go
index 54981b66976827be693fdfaef2e10d6299703900..20ee764631ee69f0714967450589531f80e5a29e 100644
--- go-ethereum/cmd/evm/internal/compiler/compiler.go
+++ op-geth/cmd/evm/internal/compiler/compiler.go
@@ -20,7 +20,7 @@ import (
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/core/asm"
+ "github.com/tenderly/op-geth/core/asm"
)
func Compile(fn string, src []byte, debug bool) (string, error) {
diff --git go-ethereum/cmd/evm/internal/t8ntool/block.go op-geth/cmd/evm/internal/t8ntool/block.go
index a2dc4734372bc1c9e8732f09f22d48bc03eba557..f80ea8cd9eb18917d125c4c92cd7d7758ea41bfe 100644
--- go-ethereum/cmd/evm/internal/t8ntool/block.go
+++ op-geth/cmd/evm/internal/t8ntool/block.go
@@ -24,13 +24,13 @@ "fmt"
"math/big"
"os"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus/clique"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus/clique"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/evm/internal/t8ntool/execution.go op-geth/cmd/evm/internal/t8ntool/execution.go
index cb975054c1b284a91baeced4af7c7eeecea568f3..14477bd9ab487630ae45193dc5efd7d6384d3fc3 100644
--- go-ethereum/cmd/evm/internal/t8ntool/execution.go
+++ op-geth/cmd/evm/internal/t8ntool/execution.go
@@ -20,24 +20,24 @@ import (
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/consensus/misc"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/triedb"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/consensus/misc"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/triedb"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/cmd/evm/internal/t8ntool/flags.go op-geth/cmd/evm/internal/t8ntool/flags.go
index c2eca8cc217d164fd3d6685cb0dc0f5d1b9eb4dc..2c70c993b7c7566e9586a8a56c194df60902b924 100644
--- go-ethereum/cmd/evm/internal/t8ntool/flags.go
+++ op-geth/cmd/evm/internal/t8ntool/flags.go
@@ -20,8 +20,8 @@ import (
"fmt"
"strings"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/tests"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/tests"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/evm/internal/t8ntool/gen_header.go op-geth/cmd/evm/internal/t8ntool/gen_header.go
index a8c8668978ed9cdc1e120dece0f0b2dd72058d0a..44f562c08d02bd503cebca75ec4b7a4bad495239 100644
--- go-ethereum/cmd/evm/internal/t8ntool/gen_header.go
+++ op-geth/cmd/evm/internal/t8ntool/gen_header.go
@@ -7,10 +7,10 @@ "encoding/json"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/types"
)
var _ = (*headerMarshaling)(nil)
diff --git go-ethereum/cmd/evm/internal/t8ntool/gen_stenv.go op-geth/cmd/evm/internal/t8ntool/gen_stenv.go
index d47db4a8765ee3b14ba478506b79bf0a4ff9ecc0..f6a8741c3be89f6027b5fd1aa90d07ed20421b4a 100644
--- go-ethereum/cmd/evm/internal/t8ntool/gen_stenv.go
+++ op-geth/cmd/evm/internal/t8ntool/gen_stenv.go
@@ -7,9 +7,9 @@ "encoding/json"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/types"
)
var _ = (*stEnvMarshaling)(nil)
diff --git go-ethereum/cmd/evm/internal/t8ntool/tracewriter.go op-geth/cmd/evm/internal/t8ntool/tracewriter.go
index e4efad112f74564280a937ddb1e2c7b4950899bd..adf553294a6e217df2ea521714454ef42095e1bd 100644
--- go-ethereum/cmd/evm/internal/t8ntool/tracewriter.go
+++ op-geth/cmd/evm/internal/t8ntool/tracewriter.go
@@ -21,10 +21,10 @@ "encoding/json"
"io"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/log"
)
// traceWriter is an vm.EVMLogger which also holds an inner logger/tracer.
diff --git go-ethereum/cmd/evm/internal/t8ntool/transaction.go op-geth/cmd/evm/internal/t8ntool/transaction.go
index 8533b78637696ccc1461e6177e937ca1f6be69a1..853cd45e38fe87c180c752380e2c8aa0eb9bdd79 100644
--- go-ethereum/cmd/evm/internal/t8ntool/transaction.go
+++ op-geth/cmd/evm/internal/t8ntool/transaction.go
@@ -24,13 +24,13 @@ "math/big"
"os"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/tests"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/tests"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/evm/internal/t8ntool/transition.go op-geth/cmd/evm/internal/t8ntool/transition.go
index 7802d49651999b0d97951342ef5896e64651b7f7..28a86366668ce9c1bb637f800651ee519f698fa8 100644
--- go-ethereum/cmd/evm/internal/t8ntool/transition.go
+++ op-geth/cmd/evm/internal/t8ntool/transition.go
@@ -24,17 +24,17 @@ "math/big"
"os"
"path"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
- "github.com/ethereum/go-ethereum/eth/tracers/logger"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/tests"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/eth/tracers/logger"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/tests"
"github.com/urfave/cli/v2"
)
@@ -210,7 +210,7 @@ Number: new(big.Int).SetUint64(env.Number - 1),
BaseFee: env.ParentBaseFee,
GasUsed: env.ParentGasUsed,
GasLimit: env.ParentGasLimit,
- })
+ }, env.Timestamp)
return nil
}
diff --git go-ethereum/cmd/evm/internal/t8ntool/tx_iterator.go op-geth/cmd/evm/internal/t8ntool/tx_iterator.go
index 8f28dc70223bc0db753c9259743d3a0e675c047e..515080aa244ba791e3294057ce0ce7baa0c553e2 100644
--- go-ethereum/cmd/evm/internal/t8ntool/tx_iterator.go
+++ op-geth/cmd/evm/internal/t8ntool/tx_iterator.go
@@ -25,12 +25,12 @@ "io"
"os"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
// txWithKey is a helper-struct, to allow us to use the types.Transaction along with
diff --git go-ethereum/cmd/evm/main.go op-geth/cmd/evm/main.go
index c3e6a4af91bae03e6a30f27fb464fbc36996024b..3a15e7803a8911bb516a849061edf27f016bc322 100644
--- go-ethereum/cmd/evm/main.go
+++ op-geth/cmd/evm/main.go
@@ -22,14 +22,14 @@ "fmt"
"math/big"
"os"
- "github.com/ethereum/go-ethereum/cmd/evm/internal/t8ntool"
- "github.com/ethereum/go-ethereum/internal/debug"
- "github.com/ethereum/go-ethereum/internal/flags"
+ "github.com/tenderly/op-geth/cmd/evm/internal/t8ntool"
+ "github.com/tenderly/op-geth/internal/debug"
+ "github.com/tenderly/op-geth/internal/flags"
"github.com/urfave/cli/v2"
// Force-load the tracer engines to trigger registration
- _ "github.com/ethereum/go-ethereum/eth/tracers/js"
- _ "github.com/ethereum/go-ethereum/eth/tracers/native"
+ _ "github.com/tenderly/op-geth/eth/tracers/js"
+ _ "github.com/tenderly/op-geth/eth/tracers/native"
)
var (
diff --git go-ethereum/cmd/evm/runner.go op-geth/cmd/evm/runner.go
index b8e8b542b7e5eab193b08cb6793a479ae3d112e1..f9b47d976a82fcd382837d0f9bf742c359f20b7f 100644
--- go-ethereum/cmd/evm/runner.go
+++ op-geth/cmd/evm/runner.go
@@ -27,19 +27,19 @@ goruntime "runtime"
"testing"
"time"
- "github.com/ethereum/go-ethereum/cmd/evm/internal/compiler"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/core/vm/runtime"
- "github.com/ethereum/go-ethereum/eth/tracers/logger"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/hashdb"
+ "github.com/tenderly/op-geth/cmd/evm/internal/compiler"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/core/vm/runtime"
+ "github.com/tenderly/op-geth/eth/tracers/logger"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/hashdb"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/evm/staterunner.go op-geth/cmd/evm/staterunner.go
index 458d809ad82efff8fbf3a7183e3750d966b3ce42..6df3d03d390f4ddb42674d6e9d0784f1ffee0ae5 100644
--- go-ethereum/cmd/evm/staterunner.go
+++ op-geth/cmd/evm/staterunner.go
@@ -22,12 +22,12 @@ "encoding/json"
"fmt"
"os"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers/logger"
- "github.com/ethereum/go-ethereum/tests"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers/logger"
+ "github.com/tenderly/op-geth/tests"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/evm/testdata/30/README.txt op-geth/cmd/evm/testdata/30/README.txt
index 84c92de8530cdf746d7ff9680c21b29cb6679d77..eeb7134485ae84e6874418ffd6cf1153126902ca 100644
--- go-ethereum/cmd/evm/testdata/30/README.txt
+++ op-geth/cmd/evm/testdata/30/README.txt
@@ -1,4 +1,4 @@
-This example comes from https://github.com/ethereum/go-ethereum/issues/27730.
+This example comes from https://github.com/tenderly/op-geth/issues/27730.
The input transactions contain three transactions, number `0` and `2` are taken from
`testdata/13`, whereas number `1` is taken from #27730.
diff --git go-ethereum/cmd/geth/accountcmd.go op-geth/cmd/geth/accountcmd.go
index cc22684e0baddd6418ff827e8753413ac8d45536..71e58b1dfc648cad16c2c9faf7f2d4cf707fdfaa 100644
--- go-ethereum/cmd/geth/accountcmd.go
+++ op-geth/cmd/geth/accountcmd.go
@@ -20,11 +20,11 @@ import (
"fmt"
"os"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/geth/chaincmd.go op-geth/cmd/geth/chaincmd.go
index d333c175599d22a2e3cf8601a61c6b822497897e..a890eafd3821a70f8a4621b858d48478e2785858 100644
--- go-ethereum/cmd/geth/chaincmd.go
+++ op-geth/cmd/geth/chaincmd.go
@@ -26,21 +26,21 @@ "strconv"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/internal/era"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/internal/era"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/params"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/geth/consolecmd.go op-geth/cmd/geth/consolecmd.go
index 526ede96192fa01d7819eca12d60dd84ee805c9a..f7cd2da416f64ec5934853484466b8887cf49287 100644
--- go-ethereum/cmd/geth/consolecmd.go
+++ op-geth/cmd/geth/consolecmd.go
@@ -20,9 +20,9 @@ import (
"fmt"
"strings"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/console"
- "github.com/ethereum/go-ethereum/internal/flags"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/console"
+ "github.com/tenderly/op-geth/internal/flags"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/geth/dbcmd.go op-geth/cmd/geth/dbcmd.go
index 1d885bd58d20a416b1e2a73203785e2c24f04a37..a22cdb9a15c3f4c847044cb9098b237052e81caa 100644
--- go-ethereum/cmd/geth/dbcmd.go
+++ op-geth/cmd/geth/dbcmd.go
@@ -27,18 +27,18 @@ "strings"
"syscall"
"time"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/console/prompt"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/trie"
"github.com/olekukonko/tablewriter"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/console/prompt"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state/snapshot"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/trie"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/geth/logtestcmd_active.go op-geth/cmd/geth/logtestcmd_active.go
index f2a2c5ded54a7d3d2189fbcf8686e9e4b27a55ee..06772d8fa779189b6cd84687d5f105b35f15e904 100644
--- go-ethereum/cmd/geth/logtestcmd_active.go
+++ op-geth/cmd/geth/logtestcmd_active.go
@@ -25,9 +25,9 @@ "math"
"math/big"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/log"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/log"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/geth/snapshot.go op-geth/cmd/geth/snapshot.go
index 4284005a02212021bb5cae47fa0480d94906f512..a2a0b59a0aebaa2122944c7ff51268454e251f0d 100644
--- go-ethereum/cmd/geth/snapshot.go
+++ op-geth/cmd/geth/snapshot.go
@@ -24,18 +24,18 @@ "fmt"
"os"
"time"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/state/pruner"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/state/pruner"
+ "github.com/tenderly/op-geth/core/state/snapshot"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
cli "github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/geth/testdata/vcheck/data.json op-geth/cmd/geth/testdata/vcheck/data.json
index e7ee2bf7e44cfb633cac0c037f7c6476a5444847..47b72dcb6deef3fc3e88a30a3007df66d7d43d7e 100644
--- go-ethereum/cmd/geth/testdata/vcheck/data.json
+++ op-geth/cmd/geth/testdata/vcheck/data.json
@@ -5,9 +5,9 @@ "uid": "GETH-2020-01",
"summary": "Mining nodes will generate erroneous PoW on epochs > `385`.",
"description": "A mining flaw could cause miners to erroneously calculate PoW, due to an index overflow, if DAG size is exceeding the maximum 32 bit unsigned value.\n\nThis occurred on the ETC chain on 2020-11-06. This is likely to trigger for ETH mainnet around block `11550000`/epoch `385`, slated to occur early January 2021.\n\nThis issue is relevant only for miners, non-mining nodes are unaffected, since non-mining nodes use a smaller verification cache instead of a full DAG.",
"links": [
- "https://github.com/ethereum/go-ethereum/pull/21793",
+ "https://github.com/tenderly/op-geth/pull/21793",
"https://blog.ethereum.org/2020/11/12/geth_security_release/",
- "https://github.com/ethereum/go-ethereum/commit/567d41d9363706b4b13ce0903804e8acf214af49"
+ "https://github.com/tenderly/op-geth/commit/567d41d9363706b4b13ce0903804e8acf214af49"
],
"introduced": "v1.6.0",
"fixed": "v1.9.24",
diff --git go-ethereum/cmd/geth/testdata/vcheck/vulnerabilities.json op-geth/cmd/geth/testdata/vcheck/vulnerabilities.json
index bee0e66dd8e5f630fc58241a767a80d5f7979e9b..d1f09fac3d641f0e3b4e5bd4c94b3570de50d2be 100644
--- go-ethereum/cmd/geth/testdata/vcheck/vulnerabilities.json
+++ op-geth/cmd/geth/testdata/vcheck/vulnerabilities.json
@@ -5,10 +5,10 @@ "uid": "GETH-2020-01",
"summary": "Mining nodes will generate erroneous PoW on epochs > `385`.",
"description": "A mining flaw could cause miners to erroneously calculate PoW, due to an index overflow, if DAG size is exceeding the maximum 32 bit unsigned value.\n\nThis occurred on the ETC chain on 2020-11-06. This is likely to trigger for ETH mainnet around block `11550000`/epoch `385`, slated to occur early January 2021.\n\nThis issue is relevant only for miners, non-mining nodes are unaffected, since non-mining nodes use a smaller verification cache instead of a full DAG.",
"links": [
- "https://github.com/ethereum/go-ethereum/pull/21793",
+ "https://github.com/tenderly/op-geth/pull/21793",
"https://blog.ethereum.org/2020/11/12/geth_security_release/",
- "https://github.com/ethereum/go-ethereum/commit/567d41d9363706b4b13ce0903804e8acf214af49",
- "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-v592-xf75-856p"
+ "https://github.com/tenderly/op-geth/commit/567d41d9363706b4b13ce0903804e8acf214af49",
+ "https://github.com/tenderly/op-geth/security/advisories/GHSA-v592-xf75-856p"
],
"introduced": "v1.6.0",
"fixed": "v1.9.24",
@@ -26,7 +26,7 @@ "links": [
"https://blog.ethereum.org/2020/11/12/geth_security_release/",
"https://groups.google.com/g/golang-announce/c/NpBGTTmKzpM",
"https://github.com/golang/go/issues/42552",
- "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-m6gx-rhvj-fh52"
+ "https://github.com/tenderly/op-geth/security/advisories/GHSA-m6gx-rhvj-fh52"
],
"introduced": "v0.0.0",
"fixed": "v1.9.24",
@@ -42,7 +42,7 @@ "summary": "A consensus flaw in Geth, related to `datacopy` precompile",
"description": "Geth erroneously performed a 'shallow' copy when the precompiled `datacopy` (at `0x00...04`) was invoked. An attacker could deploy a contract that uses the shallow copy to corrupt the contents of the `RETURNDATA`, thus causing a consensus failure.",
"links": [
"https://blog.ethereum.org/2020/11/12/geth_security_release/",
- "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-69v6-xc2j-r2jf"
+ "https://github.com/tenderly/op-geth/security/advisories/GHSA-69v6-xc2j-r2jf"
],
"introduced": "v1.9.7",
"fixed": "v1.9.17",
@@ -55,13 +55,13 @@ {
"name": "Geth DoS via MULMOD",
"uid": "GETH-2020-04",
"summary": "A denial-of-service issue can be used to crash Geth nodes during block processing",
- "description": "Affected versions suffer from a vulnerability which can be exploited through the `MULMOD` operation, by specifying a modulo of `0`: `mulmod(a,b,0)`, causing a `panic` in the underlying library. \nThe crash was in the `uint256` library, where a buffer [underflowed](https://github.com/holiman/uint256/blob/4ce82e695c10ddad57215bdbeafb68b8c5df2c30/uint256.go#L442).\n\n\tif `d == 0`, `dLen` remains `0`\n\nand https://github.com/holiman/uint256/blob/4ce82e695c10ddad57215bdbeafb68b8c5df2c30/uint256.go#L451 will try to access index `[-1]`.\n\nThe `uint256` library was first merged in this [commit](https://github.com/ethereum/go-ethereum/commit/cf6674539c589f80031f3371a71c6a80addbe454), on 2020-06-08. \nExploiting this vulnerabilty would cause all vulnerable nodes to drop off the network. \n\nThe issue was brought to our attention through a [bug report](https://github.com/ethereum/go-ethereum/issues/21367), showing a `panic` occurring on sync from genesis on the Ropsten network.\n \nIt was estimated that the least obvious way to fix this would be to merge the fix into `uint256`, make a new release of that library and then update the geth-dependency.\n",
+ "description": "Affected versions suffer from a vulnerability which can be exploited through the `MULMOD` operation, by specifying a modulo of `0`: `mulmod(a,b,0)`, causing a `panic` in the underlying library. \nThe crash was in the `uint256` library, where a buffer [underflowed](https://github.com/holiman/uint256/blob/4ce82e695c10ddad57215bdbeafb68b8c5df2c30/uint256.go#L442).\n\n\tif `d == 0`, `dLen` remains `0`\n\nand https://github.com/holiman/uint256/blob/4ce82e695c10ddad57215bdbeafb68b8c5df2c30/uint256.go#L451 will try to access index `[-1]`.\n\nThe `uint256` library was first merged in this [commit](https://github.com/tenderly/op-geth/commit/cf6674539c589f80031f3371a71c6a80addbe454), on 2020-06-08. \nExploiting this vulnerabilty would cause all vulnerable nodes to drop off the network. \n\nThe issue was brought to our attention through a [bug report](https://github.com/tenderly/op-geth/issues/21367), showing a `panic` occurring on sync from genesis on the Ropsten network.\n \nIt was estimated that the least obvious way to fix this would be to merge the fix into `uint256`, make a new release of that library and then update the geth-dependency.\n",
"links": [
"https://blog.ethereum.org/2020/11/12/geth_security_release/",
- "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-jm5c-rv3w-w83m",
+ "https://github.com/tenderly/op-geth/security/advisories/GHSA-jm5c-rv3w-w83m",
"https://github.com/holiman/uint256/releases/tag/v1.1.1",
"https://github.com/holiman/uint256/pull/80",
- "https://github.com/ethereum/go-ethereum/pull/21368"
+ "https://github.com/tenderly/op-geth/pull/21368"
],
"introduced": "v1.9.16",
"fixed": "v1.9.18",
@@ -76,8 +76,8 @@ "uid": "GETH-2020-05",
"summary": "A DoS vulnerability can make a LES server crash.",
"description": "A DoS vulnerability can make a LES server crash via malicious GetProofsV2 request from a connected LES client.\n\nThe vulnerability was patched in #21896.\n\nThis vulnerability only concern users explicitly running geth as a light server",
"links": [
- "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-r33q-22hv-j29q",
- "https://github.com/ethereum/go-ethereum/pull/21896"
+ "https://github.com/tenderly/op-geth/security/advisories/GHSA-r33q-22hv-j29q",
+ "https://github.com/tenderly/op-geth/pull/21896"
],
"introduced": "v1.8.0",
"fixed": "v1.9.25",
@@ -92,9 +92,9 @@ "uid": "GETH-2020-06",
"introduced": "v1.9.4",
"fixed": "v1.9.20",
"summary": "A consensus-vulnerability in Geth could cause a chain split, where vulnerable versions refuse to accept the canonical chain.",
- "description": "A flaw was repoted at 2020-08-11 by John Youngseok Yang (Software Platform Lab), where a particular sequence of transactions could cause a consensus failure.\n\n- Tx 1:\n - `sender` invokes `caller`.\n - `caller` invokes `0xaa`. `0xaa` has 3 wei, does a self-destruct-to-self\n - `caller` does a `1 wei` -call to `0xaa`, who thereby has 1 wei (the code in `0xaa` still executed, since the tx is still ongoing, but doesn't redo the selfdestruct, it takes a different path if callvalue is non-zero)\n\n-Tx 2:\n - `sender` does a 5-wei call to 0xaa. No exec (since no code). \n\nIn geth, the result would be that `0xaa` had `6 wei`, whereas OE reported (correctly) `5` wei. Furthermore, in geth, if the second tx was not executed, the `0xaa` would be destructed, resulting in `0 wei`. Thus obviously wrong. \n\nIt was determined that the root cause was this [commit](https://github.com/ethereum/go-ethereum/commit/223b950944f494a5b4e0957fd9f92c48b09037ad) from [this PR](https://github.com/ethereum/go-ethereum/pull/19953). The semantics of `createObject` was subtly changd, into returning a non-nil object (with `deleted=true`) where it previously did not if the account had been destructed. This return value caused the new object to inherit the old `balance`.\n",
+ "description": "A flaw was repoted at 2020-08-11 by John Youngseok Yang (Software Platform Lab), where a particular sequence of transactions could cause a consensus failure.\n\n- Tx 1:\n - `sender` invokes `caller`.\n - `caller` invokes `0xaa`. `0xaa` has 3 wei, does a self-destruct-to-self\n - `caller` does a `1 wei` -call to `0xaa`, who thereby has 1 wei (the code in `0xaa` still executed, since the tx is still ongoing, but doesn't redo the selfdestruct, it takes a different path if callvalue is non-zero)\n\n-Tx 2:\n - `sender` does a 5-wei call to 0xaa. No exec (since no code). \n\nIn geth, the result would be that `0xaa` had `6 wei`, whereas OE reported (correctly) `5` wei. Furthermore, in geth, if the second tx was not executed, the `0xaa` would be destructed, resulting in `0 wei`. Thus obviously wrong. \n\nIt was determined that the root cause was this [commit](https://github.com/tenderly/op-geth/commit/223b950944f494a5b4e0957fd9f92c48b09037ad) from [this PR](https://github.com/tenderly/op-geth/pull/19953). The semantics of `createObject` was subtly changd, into returning a non-nil object (with `deleted=true`) where it previously did not if the account had been destructed. This return value caused the new object to inherit the old `balance`.\n",
"links": [
- "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-xw37-57qp-9mm4"
+ "https://github.com/tenderly/op-geth/security/advisories/GHSA-xw37-57qp-9mm4"
],
"published": "2020-12-10",
"severity": "High",
@@ -122,9 +122,9 @@ "uid": "GETH-2021-02",
"summary": "A consensus-flaw in the Geth EVM could cause a node to deviate from the canonical chain.",
"description": "A memory-corruption bug within the EVM can cause a consensus error, where vulnerable nodes obtain a different `stateRoot` when processing a maliciously crafted transaction. This, in turn, would lead to the chain being split: mainnet splitting in two forks.\n\nAll Geth versions supporting the London hard fork are vulnerable (the bug is older than London), so all users should update.\n\nThis bug was exploited on Mainnet at block 13107518.\n\nCredits for the discovery go to @guidovranken (working for Sentnl during an audit of the Telos EVM) and reported via bounty@ethereum.org.",
"links": [
- "https://github.com/ethereum/go-ethereum/blob/master/docs/postmortems/2021-08-22-split-postmortem.md",
- "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-9856-9gg9-qcmq",
- "https://github.com/ethereum/go-ethereum/releases/tag/v1.10.8"
+ "https://github.com/tenderly/op-geth/blob/master/docs/postmortems/2021-08-22-split-postmortem.md",
+ "https://github.com/tenderly/op-geth/security/advisories/GHSA-9856-9gg9-qcmq",
+ "https://github.com/tenderly/op-geth/releases/tag/v1.10.8"
],
"introduced": "v1.10.0",
"fixed": "v1.10.8",
@@ -137,11 +137,11 @@ {
"name": "DoS via malicious `snap/1` request",
"uid": "GETH-2021-03",
"summary": "A vulnerable node is susceptible to crash when processing a maliciously crafted message from a peer, via the snap/1 protocol. The crash can be triggered by sending a malicious snap/1 GetTrieNodes package.",
- "description": "The `snap/1` protocol handler contains two vulnerabilities related to the `GetTrieNodes` packet, which can be exploited to crash the node. Full details are available at the Github security [advisory](https://github.com/ethereum/go-ethereum/security/advisories/GHSA-59hh-656j-3p7v)",
+ "description": "The `snap/1` protocol handler contains two vulnerabilities related to the `GetTrieNodes` packet, which can be exploited to crash the node. Full details are available at the Github security [advisory](https://github.com/tenderly/op-geth/security/advisories/GHSA-59hh-656j-3p7v)",
"links": [
- "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-59hh-656j-3p7v",
+ "https://github.com/tenderly/op-geth/security/advisories/GHSA-59hh-656j-3p7v",
"https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities",
- "https://github.com/ethereum/go-ethereum/pull/23657"
+ "https://github.com/tenderly/op-geth/pull/23657"
],
"introduced": "v1.10.0",
"fixed": "v1.10.9",
@@ -154,11 +154,11 @@ {
"name": "DoS via malicious p2p message",
"uid": "GETH-2022-01",
"summary": "A vulnerable node can crash via p2p messages sent from an attacker node, if running with non-default log options.",
- "description": "A vulnerable node, if configured to use high verbosity logging, can be made to crash when handling specially crafted p2p messages sent from an attacker node. Full details are available at the Github security [advisory](https://github.com/ethereum/go-ethereum/security/advisories/GHSA-wjxw-gh3m-7pm5)",
+ "description": "A vulnerable node, if configured to use high verbosity logging, can be made to crash when handling specially crafted p2p messages sent from an attacker node. Full details are available at the Github security [advisory](https://github.com/tenderly/op-geth/security/advisories/GHSA-wjxw-gh3m-7pm5)",
"links": [
- "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-wjxw-gh3m-7pm5",
+ "https://github.com/tenderly/op-geth/security/advisories/GHSA-wjxw-gh3m-7pm5",
"https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities",
- "https://github.com/ethereum/go-ethereum/pull/24507"
+ "https://github.com/tenderly/op-geth/pull/24507"
],
"introduced": "v1.10.0",
"fixed": "v1.10.17",
diff --git go-ethereum/cmd/geth/verkle.go op-geth/cmd/geth/verkle.go
index 420b063d8ba18b3d17f3acde05959c4ece6d25bf..716ea634028a6ff890564a94292fa287fe1b7f49 100644
--- go-ethereum/cmd/geth/verkle.go
+++ op-geth/cmd/geth/verkle.go
@@ -23,12 +23,12 @@ "errors"
"fmt"
"os"
- "github.com/ethereum/go-ethereum/cmd/utils"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/log"
"github.com/gballet/go-verkle"
+ "github.com/tenderly/op-geth/cmd/utils"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/log"
cli "github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/geth/version_check.go op-geth/cmd/geth/version_check.go
index 237556788eb9f32ac7d347e65a7dfb28c28dd55a..bf0e4e4a9a6ab5f0444d1b746d3cbba217f33864 100644
--- go-ethereum/cmd/geth/version_check.go
+++ op-geth/cmd/geth/version_check.go
@@ -26,8 +26,8 @@ "os"
"regexp"
"strings"
- "github.com/ethereum/go-ethereum/log"
"github.com/jedisct1/go-minisign"
+ "github.com/tenderly/op-geth/log"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/p2psim/main.go op-geth/cmd/p2psim/main.go
index a0f5f0d2889d485f63fd067e75f9ff3a5b4c8704..dba3107c4628b557c0964f02b22c5f544e437f7e 100644
--- go-ethereum/cmd/p2psim/main.go
+++ op-geth/cmd/p2psim/main.go
@@ -44,13 +44,13 @@ "os"
"strings"
"text/tabwriter"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/simulations"
- "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/simulations"
+ "github.com/tenderly/op-geth/p2p/simulations/adapters"
+ "github.com/tenderly/op-geth/rpc"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/rlpdump/main.go op-geth/cmd/rlpdump/main.go
index 7e1d314d4924d41f41a06de5240ff141433c9058..34b8152f0fbbebed3584c250899092e8d9f5296a 100644
--- go-ethereum/cmd/rlpdump/main.go
+++ op-geth/cmd/rlpdump/main.go
@@ -30,8 +30,8 @@ "os"
"strconv"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/rlp"
)
var (
diff --git go-ethereum/cmd/utils/cmd.go op-geth/cmd/utils/cmd.go
index 4b571646655609b184318c1ada5e1c1b66de8f2a..63b9a8ab7eb211dbe7d2bd8fbcafbe8a54ef78e2 100644
--- go-ethereum/cmd/utils/cmd.go
+++ op-geth/cmd/utils/cmd.go
@@ -33,20 +33,20 @@ "strings"
"syscall"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/internal/debug"
- "github.com/ethereum/go-ethereum/internal/era"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state/snapshot"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/internal/debug"
+ "github.com/tenderly/op-geth/internal/era"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/utils/flags_legacy.go op-geth/cmd/utils/flags_legacy.go
index 243abd831105bf3d5159c170e7a69eab0a22688e..75a4242c6af5cd846a0b5f20ecc6fbe169cb9eca 100644
--- go-ethereum/cmd/utils/flags_legacy.go
+++ op-geth/cmd/utils/flags_legacy.go
@@ -19,8 +19,8 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/internal/flags"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/internal/flags"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/cmd/utils/prompt.go op-geth/cmd/utils/prompt.go
index f513e381888f4e99aa321137191d410fccceb6f8..761c382077df52872bf79ca95909cdb496134ea3 100644
--- go-ethereum/cmd/utils/prompt.go
+++ op-geth/cmd/utils/prompt.go
@@ -20,7 +20,7 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/console/prompt"
+ "github.com/tenderly/op-geth/console/prompt"
)
// GetPassPhrase displays the given text(prompt) to the user and requests some textual
diff --git go-ethereum/common/bytes.go op-geth/common/bytes.go
index d1f5c6c9958650e23c6ca208808c212fa3aa41ed..9149bab50b12d57ca0aca8be02b707db8188b232 100644
--- go-ethereum/common/bytes.go
+++ op-geth/common/bytes.go
@@ -21,7 +21,7 @@ import (
"encoding/hex"
"errors"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common/hexutil"
)
// FromHex returns the bytes represented by the hexadecimal string s.
diff --git go-ethereum/common/debug.go op-geth/common/debug.go
index 28c52b4a9cd51cb64f2b5b31f8de9ddf586a8a91..6462df0c60020013b601d6d1099bde0e056a7734 100644
--- go-ethereum/common/debug.go
+++ op-geth/common/debug.go
@@ -26,7 +26,7 @@ )
// Report gives off a warning requesting the user to submit an issue to the github tracker.
func Report(extra ...interface{}) {
- fmt.Fprintln(os.Stderr, "You've encountered a sought after, hard to reproduce bug. Please report this to the developers <3 https://github.com/ethereum/go-ethereum/issues")
+ fmt.Fprintln(os.Stderr, "You've encountered a sought after, hard to reproduce bug. Please report this to the developers <3 https://github.com/tenderly/op-geth/issues")
fmt.Fprintln(os.Stderr, extra...)
_, file, line, _ := runtime.Caller(1)
diff --git go-ethereum/common/prque/lazyqueue.go op-geth/common/prque/lazyqueue.go
index 59bda72fa7e7668ee2fca0e9b0934e727eae0e7e..e21690a86daa6a0dc411c7a5fba18a19fe9d7067 100644
--- go-ethereum/common/prque/lazyqueue.go
+++ op-geth/common/prque/lazyqueue.go
@@ -20,7 +20,7 @@ import (
"container/heap"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
+ "github.com/tenderly/op-geth/common/mclock"
"golang.org/x/exp/constraints"
)
diff --git go-ethereum/common/types.go op-geth/common/types.go
index aadca87f82af89543de3387e24a90cba5fe1846f..d9a0b64ccaefe261f0f143f3110e95dc1443e0d5 100644
--- go-ethereum/common/types.go
+++ op-geth/common/types.go
@@ -29,7 +29,7 @@ "reflect"
"strconv"
"strings"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common/hexutil"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/consensus/beacon/faker.go op-geth/consensus/beacon/faker.go
index 981e345e3e1ddf54671e57048d34228274bd93e2..4efc616b0c8837d1b5310d6649852ace3d8b4012 100644
--- go-ethereum/consensus/beacon/faker.go
+++ op-geth/consensus/beacon/faker.go
@@ -19,8 +19,8 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core/types"
)
// NewFaker creates a fake consensus engine for testing.
diff --git go-ethereum/consensus/clique/api.go op-geth/consensus/clique/api.go
index 374b50692d80e3d28302601da482758eee4afe47..0a910e137d642629b43ddaebb9845fb7aa5a1879 100644
--- go-ethereum/consensus/clique/api.go
+++ op-geth/consensus/clique/api.go
@@ -20,12 +20,12 @@ import (
"encoding/json"
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/rpc"
)
// API is a user facing RPC API to allow controlling the signer and voting
diff --git go-ethereum/consensus/clique/clique.go op-geth/consensus/clique/clique.go
index c693189ea5effd24af980a29f83622e6de73e828..04c7054b8b023ac1e872ebc107853f5acf3fbb21 100644
--- go-ethereum/consensus/clique/clique.go
+++ op-geth/consensus/clique/clique.go
@@ -27,22 +27,22 @@ "math/rand"
"sync"
"time"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- lru "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/misc"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ lru "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/misc"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/rpc"
+ "github.com/tenderly/op-geth/trie"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/consensus/clique/snapshot.go op-geth/consensus/clique/snapshot.go
index a97115121b823b240188886f38bc881175849d1e..d681d7e55d388400669d071d8ba1a6f7f126f504 100644
--- go-ethereum/consensus/clique/snapshot.go
+++ op-geth/consensus/clique/snapshot.go
@@ -21,13 +21,13 @@ "bytes"
"encoding/json"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/consensus/consensus.go op-geth/consensus/consensus.go
index 3a2c2d2229165b3f2a3baada2cc96be0c737f3a5..200394f6aa9b0f07c78e18c5e7433156bfb2e8e4 100644
--- go-ethereum/consensus/consensus.go
+++ op-geth/consensus/consensus.go
@@ -20,11 +20,11 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
// ChainHeaderReader defines a small collection of methods needed to access the local
diff --git go-ethereum/consensus/ethash/consensus.go op-geth/consensus/ethash/consensus.go
index c2936fd4b341c30337cfbd46b030d82392544f02..03571d911d4921083735768e2fd189c3d2ef3ad7 100644
--- go-ethereum/consensus/ethash/consensus.go
+++ op-geth/consensus/ethash/consensus.go
@@ -23,17 +23,17 @@ "math/big"
"time"
mapset "github.com/deckarep/golang-set/v2"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/misc"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/misc"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/consensus/ethash/difficulty.go op-geth/consensus/ethash/difficulty.go
index 66a18059c617e263b3fa1ec3fdb3856294c6be48..9f5bed78d7fafc8f1ecf959221e39d6633919b09 100644
--- go-ethereum/consensus/ethash/difficulty.go
+++ op-geth/consensus/ethash/difficulty.go
@@ -19,8 +19,8 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/core/types"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/core/types"
)
const (
diff --git go-ethereum/consensus/ethash/ethash.go op-geth/consensus/ethash/ethash.go
index f37ec2605676e0e4930fec56b0a4af27c4d30de2..d7fc2e343818aca40b8d68dcf3350a18fa1e5fcf 100644
--- go-ethereum/consensus/ethash/ethash.go
+++ op-geth/consensus/ethash/ethash.go
@@ -20,9 +20,9 @@
import (
"time"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rpc"
)
// Ethash is a consensus engine based on proof-of-work implementing the ethash
diff --git go-ethereum/consensus/merger.go op-geth/consensus/merger.go
index ffbcbf2b8569bd679eb58d9b5ddeb1f2ba32964d..8b7c7aac4e27467622d68b4914a253e5ca689a4e 100644
--- go-ethereum/consensus/merger.go
+++ op-geth/consensus/merger.go
@@ -20,10 +20,10 @@ import (
"fmt"
"sync"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
)
// transitionStatus describes the status of eth1/2 transition. This switch
diff --git go-ethereum/consensus/misc/create2deployer.go op-geth/consensus/misc/create2deployer.go
new file mode 100644
index 0000000000000000000000000000000000000000..2dabfafda5d703da57909e4e883a5a0051d6bfd5
--- /dev/null
+++ op-geth/consensus/misc/create2deployer.go
@@ -0,0 +1,37 @@
+package misc
+
+import (
+ "github.com/ethereum-optimism/superchain-registry/superchain"
+
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+)
+
+// The original create2deployer contract could not be deployed to Base mainnet at
+// the canonical address of 0x13b0D85CcB8bf860b6b79AF3029fCA081AE9beF2 due to
+// an accidental nonce increment from a deposit transaction. See
+// https://github.com/pcaversaccio/create2deployer/issues/128 for context. This
+// file applies the contract code to the canonical address manually in the Canyon
+// hardfork.
+
+var create2DeployerAddress = common.HexToAddress("0x13b0D85CcB8bf860b6b79AF3029fCA081AE9beF2")
+var create2DeployerCodeHash = common.HexToHash("0xb0550b5b431e30d38000efb7107aaa0ade03d48a7198a140edda9d27134468b2")
+var create2DeployerCode []byte
+
+func init() {
+ code, err := superchain.LoadContractBytecode(superchain.Hash(create2DeployerCodeHash))
+ if err != nil {
+ panic(err)
+ }
+ create2DeployerCode = code
+}
+
+func EnsureCreate2Deployer(c *params.ChainConfig, timestamp uint64, db vm.StateDB) {
+ if !c.IsOptimism() || c.CanyonTime == nil || *c.CanyonTime != timestamp {
+ return
+ }
+ log.Info("Setting Create2Deployer code", "address", create2DeployerAddress, "codeHash", create2DeployerCodeHash)
+ db.SetCode(create2DeployerAddress, create2DeployerCode)
+}
diff --git go-ethereum/consensus/misc/dao.go op-geth/consensus/misc/dao.go
index e21a44f63de35aaebdebdd3f0b834d7402113cbb..e1b7d5041d563690c788ff6bd63f8548c954c07d 100644
--- go-ethereum/consensus/misc/dao.go
+++ op-geth/consensus/misc/dao.go
@@ -21,10 +21,10 @@ "bytes"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
var (
diff --git go-ethereum/consensus/misc/eip4844/eip4844.go op-geth/consensus/misc/eip4844/eip4844.go
index 2dad9a0cd3de18ac8db0dde8ba7101300b11d6d9..788de0baa25227d7fb0ab8aaf793ffda8e627ab5 100644
--- go-ethereum/consensus/misc/eip4844/eip4844.go
+++ op-geth/consensus/misc/eip4844/eip4844.go
@@ -21,8 +21,8 @@ "errors"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
var (
diff --git go-ethereum/consensus/misc/gaslimit.go op-geth/consensus/misc/gaslimit.go
index dfcabd9a802c4341dbc25ba96d76b4ccc6e550b5..16455430cff508d968a04d6da52e419646a916fa 100644
--- go-ethereum/consensus/misc/gaslimit.go
+++ op-geth/consensus/misc/gaslimit.go
@@ -19,7 +19,7 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/params"
)
// VerifyGaslimit verifies the header gas limit according increase/decrease
diff --git go-ethereum/console/bridge.go op-geth/console/bridge.go
index 37578041ca9e4a357a6268f47c9113cd22219460..ac0bd1e154fb2958b4d0674879325ca5bf7d8c87 100644
--- go-ethereum/console/bridge.go
+++ op-geth/console/bridge.go
@@ -26,12 +26,12 @@ "strings"
"time"
"github.com/dop251/goja"
- "github.com/ethereum/go-ethereum/accounts/scwallet"
- "github.com/ethereum/go-ethereum/accounts/usbwallet"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/console/prompt"
- "github.com/ethereum/go-ethereum/internal/jsre"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/accounts/scwallet"
+ "github.com/tenderly/op-geth/accounts/usbwallet"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/console/prompt"
+ "github.com/tenderly/op-geth/internal/jsre"
+ "github.com/tenderly/op-geth/rpc"
)
// bridge is a collection of JavaScript utility methods to bride the .js runtime
diff --git go-ethereum/console/console.go op-geth/console/console.go
index cdee53684ecfa89fd5ca33e02126f6d880218a85..eac71572ec7b0fe064f07f9ef6ff96a73d652dc2 100644
--- go-ethereum/console/console.go
+++ op-geth/console/console.go
@@ -30,14 +30,14 @@ "sync"
"syscall"
"github.com/dop251/goja"
- "github.com/ethereum/go-ethereum/console/prompt"
- "github.com/ethereum/go-ethereum/internal/jsre"
- "github.com/ethereum/go-ethereum/internal/jsre/deps"
- "github.com/ethereum/go-ethereum/internal/web3ext"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/mattn/go-colorable"
"github.com/peterh/liner"
+ "github.com/tenderly/op-geth/console/prompt"
+ "github.com/tenderly/op-geth/internal/jsre"
+ "github.com/tenderly/op-geth/internal/jsre/deps"
+ "github.com/tenderly/op-geth/internal/web3ext"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rpc"
)
var (
diff --git go-ethereum/core/asm/asm.go op-geth/core/asm/asm.go
index 294eb6ffaad7cad2873e36fb715d90a2ab5967fb..253dd5d113cf47e9e1e12fae285a0bd50e0c14e4 100644
--- go-ethereum/core/asm/asm.go
+++ op-geth/core/asm/asm.go
@@ -21,7 +21,7 @@ import (
"encoding/hex"
"fmt"
- "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/tenderly/op-geth/core/vm"
)
// Iterator for disassembled EVM instructions
diff --git go-ethereum/core/asm/compiler.go op-geth/core/asm/compiler.go
index 02c589b2c1a90a49fbe1bc1dbbabeecf7e15037a..84d26b747d6c179775af01ba2499070a340a398d 100644
--- go-ethereum/core/asm/compiler.go
+++ op-geth/core/asm/compiler.go
@@ -24,8 +24,8 @@ "math/big"
"os"
"strings"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/vm"
)
// Compiler contains information about the parsed source
diff --git go-ethereum/core/block_validator.go op-geth/core/block_validator.go
index f3d65cea25ff351bd750fa90c9b21d29ef86c8e6..65f5d33f609fc6546f67dc4999911d05fc8261e1 100644
--- go-ethereum/core/block_validator.go
+++ op-geth/core/block_validator.go
@@ -20,11 +20,11 @@ import (
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie"
)
// BlockValidator is responsible for validating block headers, uncles and
diff --git go-ethereum/core/blockchain_insert.go op-geth/core/blockchain_insert.go
index 9bf662b6b7102e66161516a3b5f64968083be328..7fa2de7b04bddaaaa4e1f048bd9eac12c8ada10a 100644
--- go-ethereum/core/blockchain_insert.go
+++ op-geth/core/blockchain_insert.go
@@ -19,10 +19,10 @@
import (
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
)
// insertStats tracks and reports on block insertion.
diff --git go-ethereum/core/blocks.go op-geth/core/blocks.go
index f20ba4aaf29562531deebf191afb3a31ffee27a8..79c13610756055da9d7c6005ead5f0a0c8bbb0ec 100644
--- go-ethereum/core/blocks.go
+++ op-geth/core/blocks.go
@@ -16,7 +16,7 @@ // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
package core
-import "github.com/ethereum/go-ethereum/common"
+import "github.com/tenderly/op-geth/common"
// BadHashes represent a set of manually tracked bad hashes (usually hard forks)
var BadHashes = map[common.Hash]bool{
diff --git go-ethereum/core/bloom_indexer.go op-geth/core/bloom_indexer.go
index 68a35d811e41e635ef24c305488bc838e6a6a29c..69748f103b694a26ea3aec837eabbf655fb50df1 100644
--- go-ethereum/core/bloom_indexer.go
+++ op-geth/core/bloom_indexer.go
@@ -20,12 +20,12 @@ import (
"context"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/bitutil"
- "github.com/ethereum/go-ethereum/core/bloombits"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/bitutil"
+ "github.com/tenderly/op-geth/core/bloombits"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
)
const (
diff --git go-ethereum/core/bloombits/generator.go op-geth/core/bloombits/generator.go
index 646151db0bfd29a51477bbb20e31f1c435b82136..232d95ef4aaf4635f6a37740abdd1935083d19f4 100644
--- go-ethereum/core/bloombits/generator.go
+++ op-geth/core/bloombits/generator.go
@@ -19,7 +19,7 @@
import (
"errors"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/core/types"
)
var (
diff --git go-ethereum/core/bloombits/matcher.go op-geth/core/bloombits/matcher.go
index 6a4cfb23db19b1cbf364ded80f11ab3fb5c1f7dd..e0a7cbaa14752c66ab16a066c6972b29233b7cab 100644
--- go-ethereum/core/bloombits/matcher.go
+++ op-geth/core/bloombits/matcher.go
@@ -26,8 +26,8 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common/bitutil"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/common/bitutil"
+ "github.com/tenderly/op-geth/crypto"
)
// bloomIndexes represents the bit indexes inside the bloom filter that belong
diff --git go-ethereum/core/chain_indexer.go op-geth/core/chain_indexer.go
index f5fce72588310199e6d0dc06fb9a6bbaf9c2fdaf..0a1cfbecb85238eed72bd407f700b6b5aad43d16 100644
--- go-ethereum/core/chain_indexer.go
+++ op-geth/core/chain_indexer.go
@@ -25,12 +25,12 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
)
// ChainIndexerBackend defines the methods needed to process chain segments in
diff --git go-ethereum/core/chain_makers.go op-geth/core/chain_makers.go
index 733030fd1c9eb8fff850a87babe2a71b491a7ba5..3686c086092955574ff2cce1eded537c9c7b2300 100644
--- go-ethereum/core/chain_makers.go
+++ op-geth/core/chain_makers.go
@@ -20,19 +20,19 @@ import (
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/consensus/misc"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/triedb"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/consensus/misc"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/triedb"
)
// BlockGen creates blocks for testing.
@@ -98,7 +98,7 @@ // block.
func (b *BlockGen) SetParentBeaconRoot(root common.Hash) {
b.header.ParentBeaconRoot = &root
var (
- blockContext = NewEVMBlockContext(b.header, b.cm, &b.header.Coinbase)
+ blockContext = NewEVMBlockContext(b.header, b.cm, &b.header.Coinbase, b.cm.config, b.statedb)
vmenv = vm.NewEVM(blockContext, vm.TxContext{}, b.statedb, b.cm.config, vm.Config{})
)
ProcessBeaconBlockRoot(root, vmenv, b.statedb)
@@ -230,7 +230,7 @@
// The gas limit and price should be derived from the parent
h.GasLimit = parent.GasLimit
if b.cm.config.IsLondon(h.Number) {
- h.BaseFee = eip1559.CalcBaseFee(b.cm.config, parent)
+ h.BaseFee = eip1559.CalcBaseFee(b.cm.config, parent, h.Time)
if !b.cm.config.IsLondon(parent.Number) {
parentGasLimit := parent.GasLimit * b.cm.config.ElasticityMultiplier()
h.GasLimit = CalcGasLimit(parentGasLimit, parentGasLimit)
@@ -320,7 +320,7 @@ // Set the difficulty for clique block. The chain maker doesn't have access
// to a chain, so the difficulty will be left unset (nil). Set it here to the
// correct value.
if b.header.Difficulty == nil {
- if config.TerminalTotalDifficulty == nil {
+ if config.TerminalTotalDifficulty == nil && !config.IsOptimismBedrock(b.header.Number) {
// Clique chain
b.header.Difficulty = big.NewInt(2)
} else {
@@ -430,7 +430,7 @@ Time: time,
}
if cm.config.IsLondon(header.Number) {
- header.BaseFee = eip1559.CalcBaseFee(cm.config, parent.Header())
+ header.BaseFee = eip1559.CalcBaseFee(cm.config, parent.Header(), header.Time)
if !cm.config.IsLondon(parent.Number()) {
parentGasLimit := parent.GasLimit() * cm.config.ElasticityMultiplier()
header.GasLimit = CalcGasLimit(parentGasLimit, parentGasLimit)
diff --git go-ethereum/core/events.go op-geth/core/events.go
index ac935a137f5f6ae5459e783802ca60c83c09937e..9f68e88f50be46bbcc8d2ba2547b6e9a9d38a766 100644
--- go-ethereum/core/events.go
+++ op-geth/core/events.go
@@ -17,8 +17,8 @@
package core
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
)
// NewTxsEvent is posted when a batch of transactions enter the transaction pool.
diff --git go-ethereum/core/forkchoice.go op-geth/core/forkchoice.go
index b293c851bf2769ad2f96328d39aa9210a6789a95..9b408302ff64911413f5d6fe3494b74193dc886c 100644
--- go-ethereum/core/forkchoice.go
+++ op-geth/core/forkchoice.go
@@ -22,11 +22,11 @@ "errors"
"math/big"
mrand "math/rand"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
)
// ChainReader defines a small collection of methods needed to access the local
diff --git go-ethereum/core/forkid/forkid.go op-geth/core/forkid/forkid.go
index 76825d3befc16f8fab6f38560df5c376f1509017..619b14e306929aca62610a4618c8c56c9cca5164 100644
--- go-ethereum/core/forkid/forkid.go
+++ op-geth/core/forkid/forkid.go
@@ -26,9 +26,9 @@ "math/big"
"reflect"
"strings"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/core/headerchain.go op-geth/core/headerchain.go
index 519a32ab80aa79c5f4441072c10253b346f5f517..0b7765715a60f0f6a1253ad1771ba5137f8bce67 100644
--- go-ethereum/core/headerchain.go
+++ op-geth/core/headerchain.go
@@ -26,15 +26,15 @@ mrand "math/rand"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
const (
diff --git go-ethereum/core/mkalloc.go op-geth/core/mkalloc.go
index 12c40c14fbeaeeb5eb66aea7216f5fc5c256085b..1941a3a785bc13134ce79ad1ee955e787f925a3a 100644
--- go-ethereum/core/mkalloc.go
+++ op-geth/core/mkalloc.go
@@ -32,9 +32,9 @@ "math/big"
"os"
"strconv"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/core/rawdb/accessors_indexes.go op-geth/core/rawdb/accessors_indexes.go
index 4f2ef0a88083bf128ede001dc9a0a530469afc72..0a931081f2d9a6b486c4807d03cde29be9132773 100644
--- go-ethereum/core/rawdb/accessors_indexes.go
+++ op-geth/core/rawdb/accessors_indexes.go
@@ -20,12 +20,12 @@ import (
"bytes"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
// ReadTxLookupEntry retrieves the positional metadata associated with a transaction
diff --git go-ethereum/core/rawdb/accessors_snapshot.go op-geth/core/rawdb/accessors_snapshot.go
index 3c82b3f73141f5a3c817bcde0daf1274c1ad5b1c..e1822a82169d7febf8f88513ce7bc75db24afbe2 100644
--- go-ethereum/core/rawdb/accessors_snapshot.go
+++ op-geth/core/rawdb/accessors_snapshot.go
@@ -19,9 +19,9 @@
import (
"encoding/binary"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
)
// ReadSnapshotDisabled retrieves if the snapshot maintenance is disabled.
diff --git go-ethereum/core/rawdb/accessors_state.go op-geth/core/rawdb/accessors_state.go
index 9ce58e7d27b933ea80c5f9707835c9e4a8eb75de..884b3da409a8a0f0d72e7272125af8af9a48e588 100644
--- go-ethereum/core/rawdb/accessors_state.go
+++ op-geth/core/rawdb/accessors_state.go
@@ -19,9 +19,9 @@
import (
"encoding/binary"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
)
// ReadPreimage retrieves a single preimage of the provided hash.
diff --git go-ethereum/core/rawdb/accessors_sync.go op-geth/core/rawdb/accessors_sync.go
index 2dc08b3b72858d84e19e3827ee4d1db183b35f0e..81baedb3c0a9404a37edde194cbe12bf33cd5ab2 100644
--- go-ethereum/core/rawdb/accessors_sync.go
+++ op-geth/core/rawdb/accessors_sync.go
@@ -17,10 +17,10 @@
package rawdb
import (
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
)
// ReadSkeletonSyncStatus retrieves the serialized sync status saved at shutdown.
diff --git go-ethereum/core/rawdb/accessors_trie.go op-geth/core/rawdb/accessors_trie.go
index ea3367db36064fd5e865283a85230573ad5226f8..7a8632c946a83ed52171cdd456d2bd3ef5107ba1 100644
--- go-ethereum/core/rawdb/accessors_trie.go
+++ op-geth/core/rawdb/accessors_trie.go
@@ -20,10 +20,10 @@ import (
"fmt"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/core/rawdb/ancient_utils.go op-geth/core/rawdb/ancient_utils.go
index 428cda544b0313bfd59ab08ffc660a425ade312d..8513bae1e43101d7aeffbe9375e2c5f6fd6d1702 100644
--- go-ethereum/core/rawdb/ancient_utils.go
+++ op-geth/core/rawdb/ancient_utils.go
@@ -20,8 +20,8 @@ import (
"fmt"
"path/filepath"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
)
type tableSize struct {
diff --git go-ethereum/core/rawdb/chain_freezer.go op-geth/core/rawdb/chain_freezer.go
index bb2c409dbbd53dd38dc9ce6777bfe14c76cd899e..a85d51e05c4830ea203df946cab536c77177a75e 100644
--- go-ethereum/core/rawdb/chain_freezer.go
+++ op-geth/core/rawdb/chain_freezer.go
@@ -22,10 +22,10 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
)
const (
diff --git go-ethereum/core/rawdb/chain_iterator.go op-geth/core/rawdb/chain_iterator.go
index 759e5913d13fea953163d2bc91a596fda4df79cb..bdc632ef233f2c150228b5cdd15742bd78c51b8c 100644
--- go-ethereum/core/rawdb/chain_iterator.go
+++ op-geth/core/rawdb/chain_iterator.go
@@ -21,12 +21,12 @@ "runtime"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/prque"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/prque"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
)
// InitDatabaseFromFreezer reinitializes an empty database from a previous batch
diff --git go-ethereum/core/rawdb/database.go op-geth/core/rawdb/database.go
index 27a9ec7412ca3215e0137af804df1c62bb18fe62..068af4afb37ae8b0892f0e12810f2e1abede2eb4 100644
--- go-ethereum/core/rawdb/database.go
+++ op-geth/core/rawdb/database.go
@@ -26,13 +26,13 @@ "path/filepath"
"strings"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/ethdb/leveldb"
- "github.com/ethereum/go-ethereum/ethdb/memorydb"
- "github.com/ethereum/go-ethereum/ethdb/pebble"
- "github.com/ethereum/go-ethereum/log"
"github.com/olekukonko/tablewriter"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/ethdb/leveldb"
+ "github.com/tenderly/op-geth/ethdb/memorydb"
+ "github.com/tenderly/op-geth/ethdb/pebble"
+ "github.com/tenderly/op-geth/log"
)
// freezerdb is a database wrapper that enables freezer data retrievals.
diff --git go-ethereum/core/rawdb/freezer.go op-geth/core/rawdb/freezer.go
index b7824ddc0d2c29aafe2a653442608ccfddfcc2f2..5cf857307c705473cd7300bee5a3f46306c13345 100644
--- go-ethereum/core/rawdb/freezer.go
+++ op-geth/core/rawdb/freezer.go
@@ -26,11 +26,11 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
"github.com/gofrs/flock"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
var (
diff --git go-ethereum/core/rawdb/freezer_batch.go op-geth/core/rawdb/freezer_batch.go
index 84a63a4518d7b41cecd599f376556668cb105240..2e3735d4031d17844b8a1fc9622fd68ad044670a 100644
--- go-ethereum/core/rawdb/freezer_batch.go
+++ op-geth/core/rawdb/freezer_batch.go
@@ -19,9 +19,9 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/golang/snappy"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/rlp"
)
// This is the maximum amount of data that will be buffered in memory
diff --git go-ethereum/core/rawdb/freezer_meta.go op-geth/core/rawdb/freezer_meta.go
index 9eef9df351df1da9428947beb5e2d64a9b1ca65f..300282fb6c696606b97052b9c4c14a359663af7e 100644
--- go-ethereum/core/rawdb/freezer_meta.go
+++ op-geth/core/rawdb/freezer_meta.go
@@ -20,8 +20,8 @@ import (
"io"
"os"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
)
const freezerVersion = 1 // The initial version tag of freezer table metadata
diff --git go-ethereum/core/rawdb/freezer_resettable.go op-geth/core/rawdb/freezer_resettable.go
index 7a8548973819b2cdca901ca950a5bbfa24157a9c..b4744cf298d02f9daf35b5d0a5873ce2c5a88aeb 100644
--- go-ethereum/core/rawdb/freezer_resettable.go
+++ op-geth/core/rawdb/freezer_resettable.go
@@ -21,8 +21,8 @@ "os"
"path/filepath"
"sync"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
)
const tmpSuffix = ".tmp"
diff --git go-ethereum/core/rawdb/freezer_table.go op-geth/core/rawdb/freezer_table.go
index 4b9d510e82856e41ec1a725019480ada7379b86d..dd65aaa8fc885fed2d04df832a8bf5cc9789cd0a 100644
--- go-ethereum/core/rawdb/freezer_table.go
+++ op-geth/core/rawdb/freezer_table.go
@@ -27,10 +27,10 @@ "path/filepath"
"sync"
"sync/atomic"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
"github.com/golang/snappy"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
var (
diff --git go-ethereum/core/rawdb/key_length_iterator.go op-geth/core/rawdb/key_length_iterator.go
index d1c5af269a319b80c11757b5e10534273bb0ba87..0c820651d32974ca828c95751d9790799af169f9 100644
--- go-ethereum/core/rawdb/key_length_iterator.go
+++ op-geth/core/rawdb/key_length_iterator.go
@@ -16,7 +16,7 @@ // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
package rawdb
-import "github.com/ethereum/go-ethereum/ethdb"
+import "github.com/tenderly/op-geth/ethdb"
// KeyLengthIterator is a wrapper for a database iterator that ensures only key-value pairs
// with a specific key length will be returned.
diff --git go-ethereum/core/rawdb/schema.go op-geth/core/rawdb/schema.go
index 11cf5b40fef666fd2cb974b900a4b3ac5ea27b04..610bc3fa684fb3df8efe0a14ac184a511526bf4b 100644
--- go-ethereum/core/rawdb/schema.go
+++ op-geth/core/rawdb/schema.go
@@ -21,9 +21,9 @@ import (
"bytes"
"encoding/binary"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/metrics"
)
// The fields below define the low level database schema prefixing.
diff --git go-ethereum/core/rawdb/table.go op-geth/core/rawdb/table.go
index 19e4ed5b5c4b5deedc12286639e2ff3655782c0d..ec0ca84583da9f1c42f0d593f3257389027123cd 100644
--- go-ethereum/core/rawdb/table.go
+++ op-geth/core/rawdb/table.go
@@ -17,7 +17,7 @@
package rawdb
import (
- "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/tenderly/op-geth/ethdb"
)
// table is a wrapper around a database that prefixes each key access with a pre-
diff --git go-ethereum/core/sender_cacher.go op-geth/core/sender_cacher.go
index 4be53619ebeca53fd715ebcb0eaf205993c32ced..3856207061c4c4a04f6bf5a080bcd123192a2374 100644
--- go-ethereum/core/sender_cacher.go
+++ op-geth/core/sender_cacher.go
@@ -19,7 +19,7 @@
import (
"runtime"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/core/types"
)
// SenderCacher is a concurrent transaction sender recoverer and cacher.
diff --git go-ethereum/core/state/access_list.go op-geth/core/state/access_list.go
index 4194691345958cf26d488d0d36b0603686755117..6063595200d14150b2d68bbec416cef7d1793f64 100644
--- go-ethereum/core/state/access_list.go
+++ op-geth/core/state/access_list.go
@@ -17,7 +17,7 @@
package state
import (
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
type accessList struct {
diff --git go-ethereum/core/state/database.go op-geth/core/state/database.go
index 7520923eef483fda12466a271a7ef9d83e40ecea..84c3845dfa56d5d0449013ad1781a1732193cc85 100644
--- go-ethereum/core/state/database.go
+++ op-geth/core/state/database.go
@@ -21,16 +21,16 @@ "errors"
"fmt"
"github.com/crate-crypto/go-ipa/banderwagon"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/utils"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/utils"
+ "github.com/tenderly/op-geth/triedb"
)
const (
diff --git go-ethereum/core/state/dump.go op-geth/core/state/dump.go
index 55abb50f1c5a1e420a324c534cfd58053e5bc306..ee3b1004803330d8358f2b4e2b860ad429d58588 100644
--- go-ethereum/core/state/dump.go
+++ op-geth/core/state/dump.go
@@ -21,12 +21,12 @@ "encoding/json"
"fmt"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
)
// DumpConfig is a set of options to control what portions of the state will be
diff --git go-ethereum/core/state/iterator.go op-geth/core/state/iterator.go
index dc84ce689be7cb6e7fe52cda608484f5950d8c0a..7ee66b2b48db780ca468d62e2d712b4a4bdb58fd 100644
--- go-ethereum/core/state/iterator.go
+++ op-geth/core/state/iterator.go
@@ -21,10 +21,10 @@ "bytes"
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
)
// nodeIterator is an iterator to traverse the entire state trie post-order,
diff --git go-ethereum/core/state/journal.go op-geth/core/state/journal.go
index 6cdc1fc8680810221d6c126b3fe00d6b9512ce14..2bf02d3f46463a39e97063068bbfb5bc7d753b71 100644
--- go-ethereum/core/state/journal.go
+++ op-geth/core/state/journal.go
@@ -17,8 +17,8 @@
package state
import (
- "github.com/ethereum/go-ethereum/common"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
)
// journalEntry is a modification entry in the state change journal that can be
diff --git go-ethereum/core/state/metrics.go op-geth/core/state/metrics.go
index 64c651461e7316844da87188f2c34ab757fe83dc..eda88b232ebcef9291bcf9379f8ed3846418b8a4 100644
--- go-ethereum/core/state/metrics.go
+++ op-geth/core/state/metrics.go
@@ -16,7 +16,7 @@ // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
package state
-import "github.com/ethereum/go-ethereum/metrics"
+import "github.com/tenderly/op-geth/metrics"
var (
accountUpdatedMeter = metrics.NewRegisteredMeter("state/update/account", nil)
diff --git go-ethereum/core/state/pruner/bloom.go op-geth/core/state/pruner/bloom.go
index dad2b5b2a8b3e81130b3b6e568fb60a399608196..2414ae7205c6f6fca8c45d1ea834ae2f6cdf9a01 100644
--- go-ethereum/core/state/pruner/bloom.go
+++ op-geth/core/state/pruner/bloom.go
@@ -21,10 +21,10 @@ "encoding/binary"
"errors"
"os"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/log"
bloomfilter "github.com/holiman/bloomfilter/v2"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/log"
)
// stateBloomHash is used to convert a trie hash or contract code hash into a 64 bit mini hash.
diff --git go-ethereum/core/state/pruner/pruner.go op-geth/core/state/pruner/pruner.go
index 59c580dacaf1a11b0bdf81d4a17be42a51231772..0f4907d1029addcdc597a51bcfd2826af118c7af 100644
--- go-ethereum/core/state/pruner/pruner.go
+++ op-geth/core/state/pruner/pruner.go
@@ -27,15 +27,15 @@ "path/filepath"
"strings"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state/snapshot"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/triedb"
)
const (
diff --git go-ethereum/core/state/snapshot/context.go op-geth/core/state/snapshot/context.go
index 67d7e41a03cadaa1070d77c0411b965a1948fca2..3a100cc4cd1f0ae427c8ed54fabbd4679f94db1b 100644
--- go-ethereum/core/state/snapshot/context.go
+++ op-geth/core/state/snapshot/context.go
@@ -22,12 +22,12 @@ "encoding/binary"
"errors"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/ethdb/memorydb"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/ethdb/memorydb"
+ "github.com/tenderly/op-geth/log"
)
const (
diff --git go-ethereum/core/state/snapshot/conversion.go op-geth/core/state/snapshot/conversion.go
index 8a0fd1989af4ea215c5e27d2bccc2c76008a817f..f756ce6b7b8a97729d689b3d5972162f333944c8 100644
--- go-ethereum/core/state/snapshot/conversion.go
+++ op-geth/core/state/snapshot/conversion.go
@@ -25,13 +25,13 @@ "runtime"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
)
// trieKV represents a trie key-value pair
diff --git go-ethereum/core/state/snapshot/difflayer.go op-geth/core/state/snapshot/difflayer.go
index 70c9f441896252c4b6a70a031fafb9f10b833b97..97a50ed14ad5814f70e98341a4427a97ab0c63f9 100644
--- go-ethereum/core/state/snapshot/difflayer.go
+++ op-geth/core/state/snapshot/difflayer.go
@@ -25,10 +25,10 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rlp"
bloomfilter "github.com/holiman/bloomfilter/v2"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/core/state/snapshot/disklayer.go op-geth/core/state/snapshot/disklayer.go
index f5518a204ca1fc5754de506990e73536a01e4090..e790ed5c7486b5827b9aac10d565d4a6586b7772 100644
--- go-ethereum/core/state/snapshot/disklayer.go
+++ op-geth/core/state/snapshot/disklayer.go
@@ -21,12 +21,12 @@ "bytes"
"sync"
"github.com/VictoriaMetrics/fastcache"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/triedb"
)
// diskLayer is a low level persistent snapshot built on top of a key-value store.
diff --git go-ethereum/core/state/snapshot/generate.go op-geth/core/state/snapshot/generate.go
index 8de4b134d38cc5cb23c10eb9f567494d47caddaa..b6dd827b6a29755e3a05cbbc6da534a48fcbefa4 100644
--- go-ethereum/core/state/snapshot/generate.go
+++ op-geth/core/state/snapshot/generate.go
@@ -23,16 +23,16 @@ "fmt"
"time"
"github.com/VictoriaMetrics/fastcache"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/triedb"
)
var (
diff --git go-ethereum/core/state/snapshot/holdable_iterator.go op-geth/core/state/snapshot/holdable_iterator.go
index 1e86ff9d822db78d9993f0523c47d824ab2264f5..d530b7d53bee64f97433bbd36c2f339585343062 100644
--- go-ethereum/core/state/snapshot/holdable_iterator.go
+++ op-geth/core/state/snapshot/holdable_iterator.go
@@ -17,8 +17,8 @@
package snapshot
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
)
// holdableIterator is a wrapper of underlying database iterator. It extends
diff --git go-ethereum/core/state/snapshot/iterator.go op-geth/core/state/snapshot/iterator.go
index c1a196c7ff8508a05d1de6a52da77c7ad5a083af..2424611e74439cb1241c519f95ddb6e1a6863f61 100644
--- go-ethereum/core/state/snapshot/iterator.go
+++ op-geth/core/state/snapshot/iterator.go
@@ -21,9 +21,9 @@ "bytes"
"fmt"
"sort"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb"
)
// Iterator is an iterator to step over all the accounts or the specific
diff --git go-ethereum/core/state/snapshot/iterator_binary.go op-geth/core/state/snapshot/iterator_binary.go
index 22184b25456318aff3d1a814c9c0ea2cc9c1dfb0..abb503234bca9705f680e66a4b9315c198ace496 100644
--- go-ethereum/core/state/snapshot/iterator_binary.go
+++ op-geth/core/state/snapshot/iterator_binary.go
@@ -19,7 +19,7 @@
import (
"bytes"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// binaryIterator is a simplistic iterator to step over the accounts or storage
diff --git go-ethereum/core/state/snapshot/iterator_fast.go op-geth/core/state/snapshot/iterator_fast.go
index 0502d9cf8596e2683160d2f4b9fb09302c234a35..4fc0455294c7e32ce4c702b64013faa77e4f8772 100644
--- go-ethereum/core/state/snapshot/iterator_fast.go
+++ op-geth/core/state/snapshot/iterator_fast.go
@@ -21,7 +21,7 @@ "bytes"
"fmt"
"sort"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/core/state/snapshot/journal.go op-geth/core/state/snapshot/journal.go
index 8513e73dd0b1f9a592c133233284ed6d3b87bd66..9ca8157d81ec2c234f01f4e32d6fd50102722ed8 100644
--- go-ethereum/core/state/snapshot/journal.go
+++ op-geth/core/state/snapshot/journal.go
@@ -25,12 +25,12 @@ "io"
"time"
"github.com/VictoriaMetrics/fastcache"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/triedb"
)
const journalVersion uint64 = 0
diff --git go-ethereum/core/state/snapshot/metrics.go op-geth/core/state/snapshot/metrics.go
index b2e884588b5dc9e00b8e2f316ad1317a7a0bb1db..ad80180d54a36c65ac267aa588c332b06b66c2b4 100644
--- go-ethereum/core/state/snapshot/metrics.go
+++ op-geth/core/state/snapshot/metrics.go
@@ -16,7 +16,7 @@ // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
package snapshot
-import "github.com/ethereum/go-ethereum/metrics"
+import "github.com/tenderly/op-geth/metrics"
// Metrics in generation
var (
diff --git go-ethereum/core/state/snapshot/snapshot.go op-geth/core/state/snapshot/snapshot.go
index 5c38cb7252f19f3555a855836e1958ee43ad657c..b72a8f846a04eeb37c03aba2ef3326896b5a4e4a 100644
--- go-ethereum/core/state/snapshot/snapshot.go
+++ op-geth/core/state/snapshot/snapshot.go
@@ -23,14 +23,14 @@ "errors"
"fmt"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/triedb"
)
var (
diff --git go-ethereum/core/state/snapshot/utils.go op-geth/core/state/snapshot/utils.go
index 62f073d2e1599c278747f23abb0abb7d14c9a558..0616545555ac910415515e40e52d92e4c04585ad 100644
--- go-ethereum/core/state/snapshot/utils.go
+++ op-geth/core/state/snapshot/utils.go
@@ -21,11 +21,11 @@ "bytes"
"fmt"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
)
// CheckDanglingStorage iterates the snap storage data, and verifies that all
diff --git go-ethereum/core/state/state_object.go op-geth/core/state/state_object.go
index fc26af68dbe7339206f556ef5626723b23e43ecc..b0dcee2b96981f88e39a69190c061f6b1a8d82a4 100644
--- go-ethereum/core/state/state_object.go
+++ op-geth/core/state/state_object.go
@@ -22,13 +22,13 @@ "fmt"
"io"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie/trienode"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie/trienode"
)
type Code []byte
diff --git go-ethereum/core/state/statedb.go op-geth/core/state/statedb.go
index ebd2143882ac953a3930fc124ef2c8a959b09069..552901abdf54599c206f5d234440e3b5034276b6 100644
--- go-ethereum/core/state/statedb.go
+++ op-geth/core/state/statedb.go
@@ -22,18 +22,18 @@ "fmt"
"sort"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/triestate"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state/snapshot"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/triestate"
)
const (
@@ -714,7 +714,7 @@ snap: s.snap,
}
// Copy the dirty states, logs, and preimages
for addr := range s.journal.dirties {
- // As documented [here](https://github.com/ethereum/go-ethereum/pull/16485#issuecomment-380438527),
+ // As documented [here](https://github.com/tenderly/op-geth/pull/16485#issuecomment-380438527),
// and in the Finalise-method, there is a case where an object is in the journal but not
// in the stateObjects: OOG after touch on ripeMD prior to Byzantium. Thus, we need to check for
// nil
@@ -1384,6 +1384,12 @@ ret[obj.addrHash] = struct{}{}
}
}
return ret
+}
+
+// OpenStorageTrie opens the storage trie for the storage root of the provided address.
+func (s *StateDB) OpenStorageTrie(addr common.Address) (Trie, error) {
+ storageRoot := s.GetStorageRoot(addr)
+ return s.db.OpenStorageTrie(s.originalRoot, addr, storageRoot, s.trie)
}
// copySet returns a deep-copied set.
diff --git go-ethereum/core/state/sync.go op-geth/core/state/sync.go
index 411b54eab0961506276dc30fb06bc3e28c9c3f74..383c8d326d46c0c105c6aeed6fd54fdc92832dec 100644
--- go-ethereum/core/state/sync.go
+++ op-geth/core/state/sync.go
@@ -17,11 +17,11 @@
package state
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
)
// NewStateSync creates a new state trie download scheduler.
diff --git go-ethereum/core/state/transient_storage.go op-geth/core/state/transient_storage.go
index 66e563efa732d48e882d3b69d53fc1c6438613e1..d8ee2fd64204d1fda862678bdf334515f6d486b4 100644
--- go-ethereum/core/state/transient_storage.go
+++ op-geth/core/state/transient_storage.go
@@ -17,7 +17,7 @@
package state
import (
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// transientStorage is a representation of EIP-1153 "Transient Storage".
diff --git go-ethereum/core/state/trie_prefetcher.go op-geth/core/state/trie_prefetcher.go
index c2a49417d4587e26e709b9f8ef149af11149e65c..8637cdaf12cc755931c23163ea974658dfec7a82 100644
--- go-ethereum/core/state/trie_prefetcher.go
+++ op-geth/core/state/trie_prefetcher.go
@@ -19,9 +19,9 @@
import (
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
var (
diff --git go-ethereum/core/txindexer.go op-geth/core/txindexer.go
index 70fe5f33220fecf14f39b0fa882392072b79f930..d38b1fc9461ffb68264090567dfe364dbc54e46a 100644
--- go-ethereum/core/txindexer.go
+++ op-geth/core/txindexer.go
@@ -20,9 +20,9 @@ import (
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
)
// TxIndexProgress is the struct describing the progress for transaction indexing.
diff --git go-ethereum/core/types.go op-geth/core/types.go
index 36eb0d1dedbedeadf8db49ea35faf77da5e1d010..9de4f9ac056e1c1a58b9135b6bf403c8dec98d94 100644
--- go-ethereum/core/types.go
+++ op-geth/core/types.go
@@ -19,9 +19,9 @@
import (
"sync/atomic"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
)
// Validator is an interface which defines the standard for block validation. It
diff --git go-ethereum/core/types/account.go op-geth/core/types/account.go
index bb0f4ca02e10d388bc219c01fdab50ba4bf797af..38d4e85abca81245ab62b5e88388d5a3f74ad656 100644
--- go-ethereum/core/types/account.go
+++ op-geth/core/types/account.go
@@ -23,9 +23,9 @@ "encoding/json"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
)
//go:generate go run github.com/fjl/gencodec -type Account -field-override accountMarshaling -out gen_account.go
diff --git go-ethereum/core/types/block.go op-geth/core/types/block.go
index 1a357baa3a4152470233bec308804044ce37c76b..16437365d1b714a2bbfc7f2b28ba9d60f8233109 100644
--- go-ethereum/core/types/block.go
+++ op-geth/core/types/block.go
@@ -26,9 +26,9 @@ "reflect"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/rlp"
)
// A BlockNonce is a 64-bit hash which proves (combined with the
diff --git go-ethereum/core/types/bloom9.go op-geth/core/types/bloom9.go
index a560a20724fd788c7edce733a01664feef81b753..df924dde039f2d84f4ef6ca6080e7f2cd4e4366c 100644
--- go-ethereum/core/types/bloom9.go
+++ op-geth/core/types/bloom9.go
@@ -21,8 +21,8 @@ "encoding/binary"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/crypto"
)
type bytesBacked interface {
diff --git go-ethereum/core/types/gen_access_tuple.go op-geth/core/types/gen_access_tuple.go
index d740b70981a39c78fed22734be864b3c95f78367..817ef1e57d4a031c75b533ff1ea704ec5b2844f2 100644
--- go-ethereum/core/types/gen_access_tuple.go
+++ op-geth/core/types/gen_access_tuple.go
@@ -6,7 +6,7 @@ import (
"encoding/json"
"errors"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// MarshalJSON marshals as JSON.
diff --git go-ethereum/core/types/gen_account.go op-geth/core/types/gen_account.go
index 4e475896a736469a60790177d44d5319435291f0..b4e332d749b47673a6b839550872ac60bc8f9c90 100644
--- go-ethereum/core/types/gen_account.go
+++ op-geth/core/types/gen_account.go
@@ -7,9 +7,9 @@ "encoding/json"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
)
var _ = (*accountMarshaling)(nil)
diff --git go-ethereum/core/types/gen_account_rlp.go op-geth/core/types/gen_account_rlp.go
index 8b424493afb8b0c6a6a56126aa7616e44871fb96..87afde73588ef783341c8e01d3d501d8b39a2ada 100644
--- go-ethereum/core/types/gen_account_rlp.go
+++ op-geth/core/types/gen_account_rlp.go
@@ -2,7 +2,7 @@ // Code generated by rlpgen. DO NOT EDIT.
package types
-import "github.com/ethereum/go-ethereum/rlp"
+import "github.com/tenderly/op-geth/rlp"
import "io"
func (obj *StateAccount) EncodeRLP(_w io.Writer) error {
diff --git go-ethereum/core/types/gen_header_json.go op-geth/core/types/gen_header_json.go
index fb1f915d01d945ad5ce42ee77b77cf0aa6b2b0e7..eade2e8b075dd1909172b46155921d3a295c215d 100644
--- go-ethereum/core/types/gen_header_json.go
+++ op-geth/core/types/gen_header_json.go
@@ -7,8 +7,8 @@ "encoding/json"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var _ = (*headerMarshaling)(nil)
diff --git go-ethereum/core/types/gen_header_rlp.go op-geth/core/types/gen_header_rlp.go
index ed6a1a002cdbaab59d8261746fd512fb90888c44..1b07c5995ccff0b1a9e07251514aa29dd14b697c 100644
--- go-ethereum/core/types/gen_header_rlp.go
+++ op-geth/core/types/gen_header_rlp.go
@@ -2,7 +2,7 @@ // Code generated by rlpgen. DO NOT EDIT.
package types
-import "github.com/ethereum/go-ethereum/rlp"
+import "github.com/tenderly/op-geth/rlp"
import "io"
func (obj *Header) EncodeRLP(_w io.Writer) error {
diff --git go-ethereum/core/types/gen_log_json.go op-geth/core/types/gen_log_json.go
index 3ffa9c2feb1a6ce3790c46dd1fd72d500fe56ca6..8aff35811791ab029629975c5b1431d5cf008e7b 100644
--- go-ethereum/core/types/gen_log_json.go
+++ op-geth/core/types/gen_log_json.go
@@ -6,8 +6,8 @@ import (
"encoding/json"
"errors"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var _ = (*logMarshaling)(nil)
diff --git go-ethereum/core/types/gen_log_rlp.go op-geth/core/types/gen_log_rlp.go
index 7e8962966842fe0dcc62c32caba35932fe5c82eb..fee8db3900795986bdac05194679f4defbfdcd2f 100644
--- go-ethereum/core/types/gen_log_rlp.go
+++ op-geth/core/types/gen_log_rlp.go
@@ -2,7 +2,7 @@ // Code generated by rlpgen. DO NOT EDIT.
package types
-import "github.com/ethereum/go-ethereum/rlp"
+import "github.com/tenderly/op-geth/rlp"
import "io"
func (obj *Log) EncodeRLP(_w io.Writer) error {
diff --git go-ethereum/core/types/gen_withdrawal_json.go op-geth/core/types/gen_withdrawal_json.go
index 983a7f7a1248b99b17ec98ef46495f6e3f268093..9b72a9ddec50136e0f9607f8195c17e47322e078 100644
--- go-ethereum/core/types/gen_withdrawal_json.go
+++ op-geth/core/types/gen_withdrawal_json.go
@@ -5,8 +5,8 @@
import (
"encoding/json"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var _ = (*withdrawalMarshaling)(nil)
diff --git go-ethereum/core/types/gen_withdrawal_rlp.go op-geth/core/types/gen_withdrawal_rlp.go
index 6a97c04c8153222badb403a8eaaa092a21343c55..74d5337568b2f353547fb1ea687c86800b6abe61 100644
--- go-ethereum/core/types/gen_withdrawal_rlp.go
+++ op-geth/core/types/gen_withdrawal_rlp.go
@@ -2,7 +2,7 @@ // Code generated by rlpgen. DO NOT EDIT.
package types
-import "github.com/ethereum/go-ethereum/rlp"
+import "github.com/tenderly/op-geth/rlp"
import "io"
func (obj *Withdrawal) EncodeRLP(_w io.Writer) error {
diff --git go-ethereum/core/types/hashes.go op-geth/core/types/hashes.go
index 43e9130fd1704c121ed1ed4bb1363ac2d243202c..dd7073b0403f64dd722f8f66ce24ba5c7949ebce 100644
--- go-ethereum/core/types/hashes.go
+++ op-geth/core/types/hashes.go
@@ -17,9 +17,9 @@
package types
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
)
var (
diff --git go-ethereum/core/types/hashing.go op-geth/core/types/hashing.go
index 224d7a87eafcb5bd8e45a0bfc4eda07aa997f815..af0d6a01563e55a81716526bc9fed4bf7ca233c4 100644
--- go-ethereum/core/types/hashing.go
+++ op-geth/core/types/hashing.go
@@ -22,9 +22,9 @@ "fmt"
"math"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/core/types/log.go op-geth/core/types/log.go
index 54c7ff6372c8cea11d20c2515d10c45ef12aa963..463f6150517e6f36c3cd698ef3c55544b78c9c5e 100644
--- go-ethereum/core/types/log.go
+++ op-geth/core/types/log.go
@@ -17,8 +17,8 @@
package types
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
//go:generate go run ../../rlp/rlpgen -type Log -out gen_log_rlp.go
diff --git go-ethereum/core/types/state_account.go op-geth/core/types/state_account.go
index 52ef843b3527f71021ca8c894a3433b645f891b4..48b2fab9addfa3a7334a9684f5184e6307d2b2e3 100644
--- go-ethereum/core/types/state_account.go
+++ op-geth/core/types/state_account.go
@@ -19,9 +19,9 @@
import (
"bytes"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/rlp"
)
//go:generate go run ../../rlp/rlpgen -type StateAccount -out gen_account_rlp.go
diff --git go-ethereum/core/types/withdrawal.go op-geth/core/types/withdrawal.go
index d1ad918f985c5eba8df928801d01165965a6f42d..11c79e2b5ec15edc1dd596759581a8d03a147410 100644
--- go-ethereum/core/types/withdrawal.go
+++ op-geth/core/types/withdrawal.go
@@ -19,9 +19,9 @@
import (
"bytes"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/rlp"
)
//go:generate go run github.com/fjl/gencodec -type Withdrawal -field-override withdrawalMarshaling -out gen_withdrawal_json.go
diff --git go-ethereum/core/vm/common.go op-geth/core/vm/common.go
index 90ba4a4ad15bc9945ec7806e83321f20fb0d61ee..a2110d2fb55db7335c66d6bc1a00e1059d2d6799 100644
--- go-ethereum/core/vm/common.go
+++ op-geth/core/vm/common.go
@@ -17,9 +17,9 @@
package vm
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
)
// calcMemSize64 calculates the required memory size, and returns
diff --git go-ethereum/core/vm/contract.go op-geth/core/vm/contract.go
index 16b669ebca27a79589f54007c1396a81863e723b..69c33a6d37aa5d78a86b1bb9969e4c37852b66fd 100644
--- go-ethereum/core/vm/contract.go
+++ op-geth/core/vm/contract.go
@@ -17,8 +17,8 @@
package vm
import (
- "github.com/ethereum/go-ethereum/common"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
)
// ContractRef is a reference to the contract's backing object
diff --git go-ethereum/core/vm/contracts.go op-geth/core/vm/contracts.go
index 33a867654e71ec9883f54d1daa19b892da3c9ee2..e5073e0af5b6ca703f694b62761f614e03372885 100644
--- go-ethereum/core/vm/contracts.go
+++ op-geth/core/vm/contracts.go
@@ -23,14 +23,15 @@ "errors"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/crypto/blake2b"
- "github.com/ethereum/go-ethereum/crypto/bls12381"
- "github.com/ethereum/go-ethereum/crypto/bn256"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/crypto/blake2b"
+ "github.com/tenderly/op-geth/crypto/bls12381"
+ "github.com/tenderly/op-geth/crypto/bn256"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/crypto/secp256r1"
+ "github.com/tenderly/op-geth/params"
"golang.org/x/crypto/ripemd160"
)
@@ -107,6 +108,22 @@ common.BytesToAddress([]byte{9}): &blake2F{},
common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{},
}
+// PrecompiledContractsFjord contains the default set of pre-compiled Ethereum
+// contracts used in the Fjord release.
+var PrecompiledContractsFjord = map[common.Address]PrecompiledContract{
+ common.BytesToAddress([]byte{1}): &ecrecover{},
+ common.BytesToAddress([]byte{2}): &sha256hash{},
+ common.BytesToAddress([]byte{3}): &ripemd160hash{},
+ common.BytesToAddress([]byte{4}): &dataCopy{},
+ common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true},
+ common.BytesToAddress([]byte{6}): &bn256AddIstanbul{},
+ common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{},
+ common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{},
+ common.BytesToAddress([]byte{9}): &blake2F{},
+ common.BytesToAddress([]byte{0x0a}): &kzgPointEvaluation{},
+ common.BytesToAddress([]byte{0x01, 0x00}): &p256Verify{},
+}
+
// PrecompiledContractsBLS contains the set of pre-compiled Ethereum
// contracts specified in EIP-2537. These are exported for testing purposes.
var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{
@@ -122,6 +139,7 @@ common.BytesToAddress([]byte{18}): &bls12381MapG2{},
}
var (
+ PrecompiledAddressesFjord []common.Address
PrecompiledAddressesCancun []common.Address
PrecompiledAddressesBerlin []common.Address
PrecompiledAddressesIstanbul []common.Address
@@ -145,11 +163,16 @@ }
for k := range PrecompiledContractsCancun {
PrecompiledAddressesCancun = append(PrecompiledAddressesCancun, k)
}
+ for k := range PrecompiledContractsFjord {
+ PrecompiledAddressesFjord = append(PrecompiledAddressesFjord, k)
+ }
}
// ActivePrecompiles returns the precompiles enabled with the current configuration.
func ActivePrecompiles(rules params.Rules) []common.Address {
switch {
+ case rules.IsOptimismFjord:
+ return PrecompiledAddressesFjord
case rules.IsCancun:
return PrecompiledAddressesCancun
case rules.IsBerlin:
@@ -1134,3 +1157,37 @@ h[0] = blobCommitmentVersionKZG
return h
}
+
+// P256VERIFY (secp256r1 signature verification)
+// implemented as a native contract
+type p256Verify struct{}
+
+// RequiredGas returns the gas required to execute the precompiled contract
+func (c *p256Verify) RequiredGas(input []byte) uint64 {
+ return params.P256VerifyGas
+}
+
+// Run executes the precompiled contract with given 160 bytes of param, returning the output and the used gas
+func (c *p256Verify) Run(input []byte) ([]byte, error) {
+ // Required input length is 160 bytes
+ const p256VerifyInputLength = 160
+ // Check the input length
+ if len(input) != p256VerifyInputLength {
+ // Input length is invalid
+ return nil, nil
+ }
+
+ // Extract the hash, r, s, x, y from the input
+ hash := input[0:32]
+ r, s := new(big.Int).SetBytes(input[32:64]), new(big.Int).SetBytes(input[64:96])
+ x, y := new(big.Int).SetBytes(input[96:128]), new(big.Int).SetBytes(input[128:160])
+
+ // Verify the secp256r1 signature
+ if secp256r1.Verify(hash, r, s, x, y) {
+ // Signature is valid
+ return common.LeftPadBytes([]byte{1}, 32), nil
+ } else {
+ // Signature is invalid
+ return nil, nil
+ }
+}
diff --git go-ethereum/core/vm/eips.go op-geth/core/vm/eips.go
index 9f06b2818feeec7f57be289705b2e46cec9da60c..ecf607287620537f8c53c1a90d9007336838da5f 100644
--- go-ethereum/core/vm/eips.go
+++ op-geth/core/vm/eips.go
@@ -20,9 +20,9 @@ import (
"fmt"
"sort"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/params"
)
var activators = map[int]func(*JumpTable){
diff --git go-ethereum/core/vm/gas_table.go op-geth/core/vm/gas_table.go
index 4b141d8f9a5d81df32b09095c9d121c3ad7750a5..9a02603707709ef0ee2c482afbe4a139a7318e74 100644
--- go-ethereum/core/vm/gas_table.go
+++ op-geth/core/vm/gas_table.go
@@ -19,9 +19,9 @@
import (
"errors"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/params"
)
// memoryGasCost calculates the quadratic gas for memory expansion. It does so
diff --git go-ethereum/core/vm/instructions.go op-geth/core/vm/instructions.go
index b8055de6bce7218aa2449dfe4cfc994d8e92a80e..7dc4b6755f8a51c84be34687b38ccbc2a01ab957 100644
--- go-ethereum/core/vm/instructions.go
+++ op-geth/core/vm/instructions.go
@@ -19,11 +19,11 @@
import (
"math"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
)
func opAdd(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
diff --git go-ethereum/core/vm/interface.go op-geth/core/vm/interface.go
index 25bfa0672067b4ffb23e9a5a299627666b4aa0fb..c341d3345aa7270dfb7a5f90fa7441f864c6b877 100644
--- go-ethereum/core/vm/interface.go
+++ op-geth/core/vm/interface.go
@@ -19,10 +19,10 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
// StateDB is an EVM database for full state querying.
diff --git go-ethereum/core/vm/interpreter.go op-geth/core/vm/interpreter.go
index 1968289f4eaa370d3857a6dee1533a9a2d6db9aa..cd28ab2958ba7bb26e220a1dc32e70cb76d7365f 100644
--- go-ethereum/core/vm/interpreter.go
+++ op-geth/core/vm/interpreter.go
@@ -17,18 +17,23 @@
package vm
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
)
+// PrecompileOverrides is a function that can be used to override the default precompiled contracts
+type PrecompileOverrides func(params.Rules, PrecompiledContract, common.Address) (PrecompiledContract, bool)
+
// Config are the configuration options for the Interpreter
type Config struct {
- Tracer EVMLogger // Opcode logger
- NoBaseFee bool // Forces the EIP-1559 baseFee to 0 (needed for 0 price calls)
- EnablePreimageRecording bool // Enables recording of SHA3/keccak preimages
- ExtraEips []int // Additional EIPS that are to be enabled
+ Tracer EVMLogger // Opcode logger
+ NoBaseFee bool // Forces the EIP-1559 baseFee to 0 (needed for 0 price calls)
+ EnablePreimageRecording bool // Enables recording of SHA3/keccak preimages
+ ExtraEips []int // Additional EIPS that are to be enabled
+ OptimismPrecompileOverrides PrecompileOverrides // Precompile overrides for Optimism
}
// ScopeContext contains the things that are per-call, such as stack and memory,
diff --git go-ethereum/core/vm/jump_table.go op-geth/core/vm/jump_table.go
index 65716f9442af00ea717163fe3d061c47faeb64bc..b69d747429ee44c2ce4d80f1080fca195d36dd24 100644
--- go-ethereum/core/vm/jump_table.go
+++ op-geth/core/vm/jump_table.go
@@ -19,7 +19,7 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/params"
)
type (
diff --git go-ethereum/core/vm/jump_table_export.go op-geth/core/vm/jump_table_export.go
index b74109da0ad14b02ec33e3dfa3e969ecb25ad850..0051685c5ddeb2cafcb75b0ba4a822e6a9d28263 100644
--- go-ethereum/core/vm/jump_table_export.go
+++ op-geth/core/vm/jump_table_export.go
@@ -19,7 +19,7 @@
import (
"errors"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/params"
)
// LookupInstructionSet returns the instruction set for the fork configured by
diff --git go-ethereum/core/vm/logger.go op-geth/core/vm/logger.go
index 2667908a84d1a90f52281893f243674888ace514..402fb17b21f01e8f77aeda92a712f01104f0983e 100644
--- go-ethereum/core/vm/logger.go
+++ op-geth/core/vm/logger.go
@@ -19,7 +19,7 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// EVMLogger is used to collect execution traces from an EVM transaction
diff --git go-ethereum/core/vm/operations_acl.go op-geth/core/vm/operations_acl.go
index f420a241058b2a2904e7e9eca621c73cc0ce4273..297fde1371f73b855f7d1448205a185131ce9b63 100644
--- go-ethereum/core/vm/operations_acl.go
+++ op-geth/core/vm/operations_acl.go
@@ -19,9 +19,9 @@
import (
"errors"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/params"
)
func makeGasSStoreFunc(clearingRefund uint64) gasFunc {
diff --git go-ethereum/core/vm/runtime/env.go op-geth/core/vm/runtime/env.go
index 34335b8e9e29e683885a5a9cac6e7871362dc46c..02424be5e904d36ca7b137f05f3a2098105c6a53 100644
--- go-ethereum/core/vm/runtime/env.go
+++ op-geth/core/vm/runtime/env.go
@@ -17,8 +17,8 @@
package runtime
import (
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/vm"
)
func NewEnv(cfg *Config) *vm.EVM {
diff --git go-ethereum/core/vm/runtime/runtime.go op-geth/core/vm/runtime/runtime.go
index 46f2bb5d5f6454016ae0c547d3be27820cf166c0..f6214819fc5f6f2b3b59da5f63865120ac6c1c2d 100644
--- go-ethereum/core/vm/runtime/runtime.go
+++ op-geth/core/vm/runtime/runtime.go
@@ -20,14 +20,14 @@ import (
"math"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/params"
)
// Config is a basic type specifying certain configuration flags for running
diff --git go-ethereum/core/vm/stack_table.go op-geth/core/vm/stack_table.go
index 10c12901afdbb56d9c77b633b1ddda31fdb2d405..08275608495103f054641a62456a7d8c428cfd9d 100644
--- go-ethereum/core/vm/stack_table.go
+++ op-geth/core/vm/stack_table.go
@@ -17,7 +17,7 @@
package vm
import (
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/params"
)
func minSwapStack(n int) int {
diff --git go-ethereum/crypto/bls12381/utils.go op-geth/crypto/bls12381/utils.go
index de8bf495fe7de6a6a9b7856878fb8848576371f0..0d9f9ca19394ff83d4c5757dee16229d5b6af8c7 100644
--- go-ethereum/crypto/bls12381/utils.go
+++ op-geth/crypto/bls12381/utils.go
@@ -20,7 +20,7 @@ import (
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
func bigFromHex(hex string) *big.Int {
diff --git go-ethereum/crypto/bn256/bn256_fast.go op-geth/crypto/bn256/bn256_fast.go
index e3c9b605184fdbd58da63a7414999135a2a7f5e2..3c688de990f8f6182ae182a8a442edf53baa2e79 100644
--- go-ethereum/crypto/bn256/bn256_fast.go
+++ op-geth/crypto/bn256/bn256_fast.go
@@ -9,7 +9,7 @@ // Package bn256 implements the Optimal Ate pairing over a 256-bit Barreto-Naehrig curve.
package bn256
import (
- bn256cf "github.com/ethereum/go-ethereum/crypto/bn256/cloudflare"
+ bn256cf "github.com/tenderly/op-geth/crypto/bn256/cloudflare"
)
// G1 is an abstract cyclic group. The zero value is suitable for use as the
diff --git go-ethereum/crypto/bn256/bn256_slow.go op-geth/crypto/bn256/bn256_slow.go
index 4c0c351e2da791cb0dfdb3715927613c8d1da685..3952410b75562a00fae789a42c4df06acd9776b4 100644
--- go-ethereum/crypto/bn256/bn256_slow.go
+++ op-geth/crypto/bn256/bn256_slow.go
@@ -8,7 +8,7 @@
// Package bn256 implements the Optimal Ate pairing over a 256-bit Barreto-Naehrig curve.
package bn256
-import bn256 "github.com/ethereum/go-ethereum/crypto/bn256/google"
+import bn256 "github.com/tenderly/op-geth/crypto/bn256/google"
// G1 is an abstract cyclic group. The zero value is suitable for use as the
// output of an operation, but cannot be used as an input.
diff --git go-ethereum/crypto/crypto.go op-geth/crypto/crypto.go
index 2492165d388ce4376636e87acde90c00549158a1..afa66ea6c35e0f681261d52d076f704a54e3e9c5 100644
--- go-ethereum/crypto/crypto.go
+++ op-geth/crypto/crypto.go
@@ -29,9 +29,9 @@ "io"
"math/big"
"os"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/crypto/ecies/params.go op-geth/crypto/ecies/params.go
index df7698ea0cbec3ca48e3beffa6b1c60c22355f99..c497788a5c1ad5e3f7bd992b207791b269282222 100644
--- go-ethereum/crypto/ecies/params.go
+++ op-geth/crypto/ecies/params.go
@@ -43,7 +43,7 @@ "errors"
"fmt"
"hash"
- ethcrypto "github.com/ethereum/go-ethereum/crypto"
+ ethcrypto "github.com/tenderly/op-geth/crypto"
)
var (
diff --git go-ethereum/crypto/kzg4844/kzg4844.go op-geth/crypto/kzg4844/kzg4844.go
index 52124df674615b704f4e7c239af4e19716f47fe2..1b51a37fc03c26dff9392ffe4ebe4a7ca4d57c8a 100644
--- go-ethereum/crypto/kzg4844/kzg4844.go
+++ op-geth/crypto/kzg4844/kzg4844.go
@@ -24,7 +24,7 @@ "hash"
"reflect"
"sync/atomic"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common/hexutil"
)
//go:embed trusted_setup.json
diff --git go-ethereum/crypto/kzg4844/kzg4844_ckzg_cgo.go op-geth/crypto/kzg4844/kzg4844_ckzg_cgo.go
index 54002856987c848fc1f620bb443acf3d3927f383..f9acf4b2f8a8d353041e437c8f321227bfc547a2 100644
--- go-ethereum/crypto/kzg4844/kzg4844_ckzg_cgo.go
+++ op-geth/crypto/kzg4844/kzg4844_ckzg_cgo.go
@@ -25,7 +25,7 @@ "sync"
gokzg4844 "github.com/crate-crypto/go-kzg-4844"
ckzg4844 "github.com/ethereum/c-kzg-4844/bindings/go"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common/hexutil"
)
// ckzgAvailable signals whether the library was compiled into Geth.
diff --git go-ethereum/crypto/secp256k1/.gitignore op-geth/crypto/secp256k1/.gitignore
deleted file mode 100644
index 802b6744a1d9fb2b9711384aca36a8790bae7f0f..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/.gitignore
+++ /dev/null
@@ -1,24 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-
-*~
diff --git go-ethereum/crypto/secp256k1/LICENSE op-geth/crypto/secp256k1/LICENSE
deleted file mode 100644
index f9090e14236bc29a71ac446c306b0e4d3c3b2065..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/LICENSE
+++ /dev/null
@@ -1,31 +0,0 @@
-Copyright (c) 2010 The Go Authors. All rights reserved.
-Copyright (c) 2011 ThePiachu. All rights reserved.
-Copyright (c) 2015 Jeffrey Wilcke. All rights reserved.
-Copyright (c) 2015 Felix Lange. All rights reserved.
-Copyright (c) 2015 Gustav Simonsson. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
- * Neither the name of the copyright holder. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git go-ethereum/crypto/secp256k1/curve.go op-geth/crypto/secp256k1/curve.go
deleted file mode 100644
index 9b26ab292859e5939eac84e9d4ea49b9acb47f02..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/curve.go
+++ /dev/null
@@ -1,297 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Copyright 2011 ThePiachu. All rights reserved.
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-// * The name of ThePiachu may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package secp256k1
-
-import (
- "crypto/elliptic"
- "math/big"
-)
-
-const (
- // number of bits in a big.Word
- wordBits = 32 << (uint64(^big.Word(0)) >> 63)
- // number of bytes in a big.Word
- wordBytes = wordBits / 8
-)
-
-// readBits encodes the absolute value of bigint as big-endian bytes. Callers
-// must ensure that buf has enough space. If buf is too short the result will
-// be incomplete.
-func readBits(bigint *big.Int, buf []byte) {
- i := len(buf)
- for _, d := range bigint.Bits() {
- for j := 0; j < wordBytes && i > 0; j++ {
- i--
- buf[i] = byte(d)
- d >>= 8
- }
- }
-}
-
-// This code is from https://github.com/ThePiachu/GoBit and implements
-// several Koblitz elliptic curves over prime fields.
-//
-// The curve methods, internally, on Jacobian coordinates. For a given
-// (x, y) position on the curve, the Jacobian coordinates are (x1, y1,
-// z1) where x = x1/z1² and y = y1/z1³. The greatest speedups come
-// when the whole calculation can be performed within the transform
-// (as in ScalarMult and ScalarBaseMult). But even for Add and Double,
-// it's faster to apply and reverse the transform than to operate in
-// affine coordinates.
-
-// A BitCurve represents a Koblitz Curve with a=0.
-// See http://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
-type BitCurve struct {
- P *big.Int // the order of the underlying field
- N *big.Int // the order of the base point
- B *big.Int // the constant of the BitCurve equation
- Gx, Gy *big.Int // (x,y) of the base point
- BitSize int // the size of the underlying field
-}
-
-func (BitCurve *BitCurve) Params() *elliptic.CurveParams {
- return &elliptic.CurveParams{
- P: BitCurve.P,
- N: BitCurve.N,
- B: BitCurve.B,
- Gx: BitCurve.Gx,
- Gy: BitCurve.Gy,
- BitSize: BitCurve.BitSize,
- }
-}
-
-// IsOnCurve returns true if the given (x,y) lies on the BitCurve.
-func (BitCurve *BitCurve) IsOnCurve(x, y *big.Int) bool {
- // y² = x³ + b
- y2 := new(big.Int).Mul(y, y) //y²
- y2.Mod(y2, BitCurve.P) //y²%P
-
- x3 := new(big.Int).Mul(x, x) //x²
- x3.Mul(x3, x) //x³
-
- x3.Add(x3, BitCurve.B) //x³+B
- x3.Mod(x3, BitCurve.P) //(x³+B)%P
-
- return x3.Cmp(y2) == 0
-}
-
-// affineFromJacobian reverses the Jacobian transform. See the comment at the
-// top of the file.
-func (BitCurve *BitCurve) affineFromJacobian(x, y, z *big.Int) (xOut, yOut *big.Int) {
- if z.Sign() == 0 {
- return new(big.Int), new(big.Int)
- }
-
- zinv := new(big.Int).ModInverse(z, BitCurve.P)
- zinvsq := new(big.Int).Mul(zinv, zinv)
-
- xOut = new(big.Int).Mul(x, zinvsq)
- xOut.Mod(xOut, BitCurve.P)
- zinvsq.Mul(zinvsq, zinv)
- yOut = new(big.Int).Mul(y, zinvsq)
- yOut.Mod(yOut, BitCurve.P)
- return
-}
-
-// Add returns the sum of (x1,y1) and (x2,y2)
-func (BitCurve *BitCurve) Add(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int) {
- // If one point is at infinity, return the other point.
- // Adding the point at infinity to any point will preserve the other point.
- if x1.Sign() == 0 && y1.Sign() == 0 {
- return x2, y2
- }
- if x2.Sign() == 0 && y2.Sign() == 0 {
- return x1, y1
- }
- z := new(big.Int).SetInt64(1)
- if x1.Cmp(x2) == 0 && y1.Cmp(y2) == 0 {
- return BitCurve.affineFromJacobian(BitCurve.doubleJacobian(x1, y1, z))
- }
- return BitCurve.affineFromJacobian(BitCurve.addJacobian(x1, y1, z, x2, y2, z))
-}
-
-// addJacobian takes two points in Jacobian coordinates, (x1, y1, z1) and
-// (x2, y2, z2) and returns their sum, also in Jacobian form.
-func (BitCurve *BitCurve) addJacobian(x1, y1, z1, x2, y2, z2 *big.Int) (*big.Int, *big.Int, *big.Int) {
- // See http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-add-2007-bl
- z1z1 := new(big.Int).Mul(z1, z1)
- z1z1.Mod(z1z1, BitCurve.P)
- z2z2 := new(big.Int).Mul(z2, z2)
- z2z2.Mod(z2z2, BitCurve.P)
-
- u1 := new(big.Int).Mul(x1, z2z2)
- u1.Mod(u1, BitCurve.P)
- u2 := new(big.Int).Mul(x2, z1z1)
- u2.Mod(u2, BitCurve.P)
- h := new(big.Int).Sub(u2, u1)
- if h.Sign() == -1 {
- h.Add(h, BitCurve.P)
- }
- i := new(big.Int).Lsh(h, 1)
- i.Mul(i, i)
- j := new(big.Int).Mul(h, i)
-
- s1 := new(big.Int).Mul(y1, z2)
- s1.Mul(s1, z2z2)
- s1.Mod(s1, BitCurve.P)
- s2 := new(big.Int).Mul(y2, z1)
- s2.Mul(s2, z1z1)
- s2.Mod(s2, BitCurve.P)
- r := new(big.Int).Sub(s2, s1)
- if r.Sign() == -1 {
- r.Add(r, BitCurve.P)
- }
- r.Lsh(r, 1)
- v := new(big.Int).Mul(u1, i)
-
- x3 := new(big.Int).Set(r)
- x3.Mul(x3, x3)
- x3.Sub(x3, j)
- x3.Sub(x3, v)
- x3.Sub(x3, v)
- x3.Mod(x3, BitCurve.P)
-
- y3 := new(big.Int).Set(r)
- v.Sub(v, x3)
- y3.Mul(y3, v)
- s1.Mul(s1, j)
- s1.Lsh(s1, 1)
- y3.Sub(y3, s1)
- y3.Mod(y3, BitCurve.P)
-
- z3 := new(big.Int).Add(z1, z2)
- z3.Mul(z3, z3)
- z3.Sub(z3, z1z1)
- if z3.Sign() == -1 {
- z3.Add(z3, BitCurve.P)
- }
- z3.Sub(z3, z2z2)
- if z3.Sign() == -1 {
- z3.Add(z3, BitCurve.P)
- }
- z3.Mul(z3, h)
- z3.Mod(z3, BitCurve.P)
-
- return x3, y3, z3
-}
-
-// Double returns 2*(x,y)
-func (BitCurve *BitCurve) Double(x1, y1 *big.Int) (*big.Int, *big.Int) {
- z1 := new(big.Int).SetInt64(1)
- return BitCurve.affineFromJacobian(BitCurve.doubleJacobian(x1, y1, z1))
-}
-
-// doubleJacobian takes a point in Jacobian coordinates, (x, y, z), and
-// returns its double, also in Jacobian form.
-func (BitCurve *BitCurve) doubleJacobian(x, y, z *big.Int) (*big.Int, *big.Int, *big.Int) {
- // See http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#doubling-dbl-2009-l
-
- a := new(big.Int).Mul(x, x) //X1²
- b := new(big.Int).Mul(y, y) //Y1²
- c := new(big.Int).Mul(b, b) //B²
-
- d := new(big.Int).Add(x, b) //X1+B
- d.Mul(d, d) //(X1+B)²
- d.Sub(d, a) //(X1+B)²-A
- d.Sub(d, c) //(X1+B)²-A-C
- d.Mul(d, big.NewInt(2)) //2*((X1+B)²-A-C)
-
- e := new(big.Int).Mul(big.NewInt(3), a) //3*A
- f := new(big.Int).Mul(e, e) //E²
-
- x3 := new(big.Int).Mul(big.NewInt(2), d) //2*D
- x3.Sub(f, x3) //F-2*D
- x3.Mod(x3, BitCurve.P)
-
- y3 := new(big.Int).Sub(d, x3) //D-X3
- y3.Mul(e, y3) //E*(D-X3)
- y3.Sub(y3, new(big.Int).Mul(big.NewInt(8), c)) //E*(D-X3)-8*C
- y3.Mod(y3, BitCurve.P)
-
- z3 := new(big.Int).Mul(y, z) //Y1*Z1
- z3.Mul(big.NewInt(2), z3) //3*Y1*Z1
- z3.Mod(z3, BitCurve.P)
-
- return x3, y3, z3
-}
-
-// ScalarBaseMult returns k*G, where G is the base point of the group and k is
-// an integer in big-endian form.
-func (BitCurve *BitCurve) ScalarBaseMult(k []byte) (*big.Int, *big.Int) {
- return BitCurve.ScalarMult(BitCurve.Gx, BitCurve.Gy, k)
-}
-
-// Marshal converts a point into the form specified in section 4.3.6 of ANSI
-// X9.62.
-func (BitCurve *BitCurve) Marshal(x, y *big.Int) []byte {
- byteLen := (BitCurve.BitSize + 7) >> 3
- ret := make([]byte, 1+2*byteLen)
- ret[0] = 4 // uncompressed point flag
- readBits(x, ret[1:1+byteLen])
- readBits(y, ret[1+byteLen:])
- return ret
-}
-
-// Unmarshal converts a point, serialised by Marshal, into an x, y pair. On
-// error, x = nil.
-func (BitCurve *BitCurve) Unmarshal(data []byte) (x, y *big.Int) {
- byteLen := (BitCurve.BitSize + 7) >> 3
- if len(data) != 1+2*byteLen {
- return
- }
- if data[0] != 4 { // uncompressed form
- return
- }
- x = new(big.Int).SetBytes(data[1 : 1+byteLen])
- y = new(big.Int).SetBytes(data[1+byteLen:])
- return
-}
-
-var theCurve = new(BitCurve)
-
-func init() {
- // See SEC 2 section 2.7.1
- // curve parameters taken from:
- // http://www.secg.org/sec2-v2.pdf
- theCurve.P, _ = new(big.Int).SetString("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 0)
- theCurve.N, _ = new(big.Int).SetString("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 0)
- theCurve.B, _ = new(big.Int).SetString("0x0000000000000000000000000000000000000000000000000000000000000007", 0)
- theCurve.Gx, _ = new(big.Int).SetString("0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", 0)
- theCurve.Gy, _ = new(big.Int).SetString("0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", 0)
- theCurve.BitSize = 256
-}
-
-// S256 returns a BitCurve which implements secp256k1.
-func S256() *BitCurve {
- return theCurve
-}
diff --git go-ethereum/crypto/secp256k1/dummy.go op-geth/crypto/secp256k1/dummy.go
deleted file mode 100644
index 65a75080f60a01f8b2c95da98f7a3b397debc4d7..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/dummy.go
+++ /dev/null
@@ -1,21 +0,0 @@
-//go:build dummy
-// +build dummy
-
-// This file is part of a workaround for `go mod vendor` which won't vendor
-// C files if there's no Go file in the same directory.
-// This would prevent the crypto/secp256k1/libsecp256k1/include/secp256k1.h file to be vendored.
-//
-// This Go file imports the c directory where there is another dummy.go file which
-// is the second part of this workaround.
-//
-// These two files combined make it so `go mod vendor` behaves correctly.
-//
-// See this issue for reference: https://github.com/golang/go/issues/26366
-
-package secp256k1
-
-import (
- _ "github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/include"
- _ "github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/src"
- _ "github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/recovery"
-)
diff --git go-ethereum/crypto/secp256k1/ext.h op-geth/crypto/secp256k1/ext.h
deleted file mode 100644
index e422fe4b496d29fedaffc352d25669d53803c1c8..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/ext.h
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be found in
-// the LICENSE file.
-
-// secp256k1_context_create_sign_verify creates a context for signing and signature verification.
-static secp256k1_context* secp256k1_context_create_sign_verify() {
- return secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
-}
-
-// secp256k1_ext_ecdsa_recover recovers the public key of an encoded compact signature.
-//
-// Returns: 1: recovery was successful
-// 0: recovery was not successful
-// Args: ctx: pointer to a context object (cannot be NULL)
-// Out: pubkey_out: the serialized 65-byte public key of the signer (cannot be NULL)
-// In: sigdata: pointer to a 65-byte signature with the recovery id at the end (cannot be NULL)
-// msgdata: pointer to a 32-byte message (cannot be NULL)
-static int secp256k1_ext_ecdsa_recover(
- const secp256k1_context* ctx,
- unsigned char *pubkey_out,
- const unsigned char *sigdata,
- const unsigned char *msgdata
-) {
- secp256k1_ecdsa_recoverable_signature sig;
- secp256k1_pubkey pubkey;
-
- if (!secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &sig, sigdata, (int)sigdata[64])) {
- return 0;
- }
- if (!secp256k1_ecdsa_recover(ctx, &pubkey, &sig, msgdata)) {
- return 0;
- }
- size_t outputlen = 65;
- return secp256k1_ec_pubkey_serialize(ctx, pubkey_out, &outputlen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
-}
-
-// secp256k1_ext_ecdsa_verify verifies an encoded compact signature.
-//
-// Returns: 1: signature is valid
-// 0: signature is invalid
-// Args: ctx: pointer to a context object (cannot be NULL)
-// In: sigdata: pointer to a 64-byte signature (cannot be NULL)
-// msgdata: pointer to a 32-byte message (cannot be NULL)
-// pubkeydata: pointer to public key data (cannot be NULL)
-// pubkeylen: length of pubkeydata
-static int secp256k1_ext_ecdsa_verify(
- const secp256k1_context* ctx,
- const unsigned char *sigdata,
- const unsigned char *msgdata,
- const unsigned char *pubkeydata,
- size_t pubkeylen
-) {
- secp256k1_ecdsa_signature sig;
- secp256k1_pubkey pubkey;
-
- if (!secp256k1_ecdsa_signature_parse_compact(ctx, &sig, sigdata)) {
- return 0;
- }
- if (!secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeydata, pubkeylen)) {
- return 0;
- }
- return secp256k1_ecdsa_verify(ctx, &sig, msgdata, &pubkey);
-}
-
-// secp256k1_ext_reencode_pubkey decodes then encodes a public key. It can be used to
-// convert between public key formats. The input/output formats are chosen depending on the
-// length of the input/output buffers.
-//
-// Returns: 1: conversion successful
-// 0: conversion unsuccessful
-// Args: ctx: pointer to a context object (cannot be NULL)
-// Out: out: output buffer that will contain the reencoded key (cannot be NULL)
-// In: outlen: length of out (33 for compressed keys, 65 for uncompressed keys)
-// pubkeydata: the input public key (cannot be NULL)
-// pubkeylen: length of pubkeydata
-static int secp256k1_ext_reencode_pubkey(
- const secp256k1_context* ctx,
- unsigned char *out,
- size_t outlen,
- const unsigned char *pubkeydata,
- size_t pubkeylen
-) {
- secp256k1_pubkey pubkey;
-
- if (!secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeydata, pubkeylen)) {
- return 0;
- }
- unsigned int flag = (outlen == 33) ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED;
- return secp256k1_ec_pubkey_serialize(ctx, out, &outlen, &pubkey, flag);
-}
-
-// secp256k1_ext_scalar_mul multiplies a point by a scalar in constant time.
-//
-// Returns: 1: multiplication was successful
-// 0: scalar was invalid (zero or overflow)
-// Args: ctx: pointer to a context object (cannot be NULL)
-// Out: point: the multiplied point (usually secret)
-// In: point: pointer to a 64-byte public point,
-// encoded as two 256bit big-endian numbers.
-// scalar: a 32-byte scalar with which to multiply the point
-int secp256k1_ext_scalar_mul(const secp256k1_context* ctx, unsigned char *point, const unsigned char *scalar) {
- int ret = 0;
- int overflow = 0;
- secp256k1_fe feX, feY;
- secp256k1_gej res;
- secp256k1_ge ge;
- secp256k1_scalar s;
- ARG_CHECK(point != NULL);
- ARG_CHECK(scalar != NULL);
- (void)ctx;
-
- secp256k1_fe_set_b32(&feX, point);
- secp256k1_fe_set_b32(&feY, point+32);
- secp256k1_ge_set_xy(&ge, &feX, &feY);
- secp256k1_scalar_set_b32(&s, scalar, &overflow);
- if (overflow || secp256k1_scalar_is_zero(&s)) {
- ret = 0;
- } else {
- secp256k1_ecmult_const(&res, &ge, &s);
- secp256k1_ge_set_gej(&ge, &res);
- /* Note: can't use secp256k1_pubkey_save here because it is not constant time. */
- secp256k1_fe_normalize(&ge.x);
- secp256k1_fe_normalize(&ge.y);
- secp256k1_fe_get_b32(point, &ge.x);
- secp256k1_fe_get_b32(point+32, &ge.y);
- ret = 1;
- }
- secp256k1_scalar_clear(&s);
- return ret;
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/.gitignore op-geth/crypto/secp256k1/libsecp256k1/.gitignore
deleted file mode 100644
index 87fea161ba5aea04756cb378d487b703bb2e2ab2..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/.gitignore
+++ /dev/null
@@ -1,49 +0,0 @@
-bench_inv
-bench_ecdh
-bench_sign
-bench_verify
-bench_schnorr_verify
-bench_recover
-bench_internal
-tests
-exhaustive_tests
-gen_context
-*.exe
-*.so
-*.a
-!.gitignore
-
-Makefile
-configure
-.libs/
-Makefile.in
-aclocal.m4
-autom4te.cache/
-config.log
-config.status
-*.tar.gz
-*.la
-libtool
-.deps/
-.dirstamp
-*.lo
-*.o
-*~
-src/libsecp256k1-config.h
-src/libsecp256k1-config.h.in
-src/ecmult_static_context.h
-build-aux/config.guess
-build-aux/config.sub
-build-aux/depcomp
-build-aux/install-sh
-build-aux/ltmain.sh
-build-aux/m4/libtool.m4
-build-aux/m4/lt~obsolete.m4
-build-aux/m4/ltoptions.m4
-build-aux/m4/ltsugar.m4
-build-aux/m4/ltversion.m4
-build-aux/missing
-build-aux/compile
-build-aux/test-driver
-src/stamp-h1
-libsecp256k1.pc
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/.travis.yml op-geth/crypto/secp256k1/libsecp256k1/.travis.yml
deleted file mode 100644
index 24395292426d697856f34b0b0d6c8f26d81d6856..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/.travis.yml
+++ /dev/null
@@ -1,69 +0,0 @@
-language: c
-sudo: false
-addons:
- apt:
- packages: libgmp-dev
-compiler:
- - clang
- - gcc
-cache:
- directories:
- - src/java/guava/
-env:
- global:
- - FIELD=auto BIGNUM=auto SCALAR=auto ENDOMORPHISM=no STATICPRECOMPUTATION=yes ASM=no BUILD=check EXTRAFLAGS= HOST= ECDH=no RECOVERY=no EXPERIMENTAL=no
- - GUAVA_URL=https://search.maven.org/remotecontent?filepath=com/google/guava/guava/18.0/guava-18.0.jar GUAVA_JAR=src/java/guava/guava-18.0.jar
- matrix:
- - SCALAR=32bit RECOVERY=yes
- - SCALAR=32bit FIELD=32bit ECDH=yes EXPERIMENTAL=yes
- - SCALAR=64bit
- - FIELD=64bit RECOVERY=yes
- - FIELD=64bit ENDOMORPHISM=yes
- - FIELD=64bit ENDOMORPHISM=yes ECDH=yes EXPERIMENTAL=yes
- - FIELD=64bit ASM=x86_64
- - FIELD=64bit ENDOMORPHISM=yes ASM=x86_64
- - FIELD=32bit ENDOMORPHISM=yes
- - BIGNUM=no
- - BIGNUM=no ENDOMORPHISM=yes RECOVERY=yes EXPERIMENTAL=yes
- - BIGNUM=no STATICPRECOMPUTATION=no
- - BUILD=distcheck
- - EXTRAFLAGS=CPPFLAGS=-DDETERMINISTIC
- - EXTRAFLAGS=CFLAGS=-O0
- - BUILD=check-java ECDH=yes EXPERIMENTAL=yes
-matrix:
- fast_finish: true
- include:
- - compiler: clang
- env: HOST=i686-linux-gnu ENDOMORPHISM=yes
- addons:
- apt:
- packages:
- - gcc-multilib
- - libgmp-dev:i386
- - compiler: clang
- env: HOST=i686-linux-gnu
- addons:
- apt:
- packages:
- - gcc-multilib
- - compiler: gcc
- env: HOST=i686-linux-gnu ENDOMORPHISM=yes
- addons:
- apt:
- packages:
- - gcc-multilib
- - compiler: gcc
- env: HOST=i686-linux-gnu
- addons:
- apt:
- packages:
- - gcc-multilib
- - libgmp-dev:i386
-before_install: mkdir -p `dirname $GUAVA_JAR`
-install: if [ ! -f $GUAVA_JAR ]; then wget $GUAVA_URL -O $GUAVA_JAR; fi
-before_script: ./autogen.sh
-script:
- - if [ -n "$HOST" ]; then export USE_HOST="--host=$HOST"; fi
- - if [ "x$HOST" = "xi686-linux-gnu" ]; then export CC="$CC -m32"; fi
- - ./configure --enable-experimental=$EXPERIMENTAL --enable-endomorphism=$ENDOMORPHISM --with-field=$FIELD --with-bignum=$BIGNUM --with-scalar=$SCALAR --enable-ecmult-static-precomputation=$STATICPRECOMPUTATION --enable-module-ecdh=$ECDH --enable-module-recovery=$RECOVERY $EXTRAFLAGS $USE_HOST && make -j2 $BUILD
-os: linux
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/COPYING op-geth/crypto/secp256k1/libsecp256k1/COPYING
deleted file mode 100644
index 4522a5990e2823f2be0db7efcbc4fca139c08025..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/COPYING
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (c) 2013 Pieter Wuille
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/Makefile.am op-geth/crypto/secp256k1/libsecp256k1/Makefile.am
deleted file mode 100644
index c071fbe2753c9bda4c8d7b74143dc15878572c4b..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/Makefile.am
+++ /dev/null
@@ -1,177 +0,0 @@
-ACLOCAL_AMFLAGS = -I build-aux/m4
-
-lib_LTLIBRARIES = libsecp256k1.la
-if USE_JNI
-JNI_LIB = libsecp256k1_jni.la
-noinst_LTLIBRARIES = $(JNI_LIB)
-else
-JNI_LIB =
-endif
-include_HEADERS = include/secp256k1.h
-noinst_HEADERS =
-noinst_HEADERS += src/scalar.h
-noinst_HEADERS += src/scalar_4x64.h
-noinst_HEADERS += src/scalar_8x32.h
-noinst_HEADERS += src/scalar_low.h
-noinst_HEADERS += src/scalar_impl.h
-noinst_HEADERS += src/scalar_4x64_impl.h
-noinst_HEADERS += src/scalar_8x32_impl.h
-noinst_HEADERS += src/scalar_low_impl.h
-noinst_HEADERS += src/group.h
-noinst_HEADERS += src/group_impl.h
-noinst_HEADERS += src/num_gmp.h
-noinst_HEADERS += src/num_gmp_impl.h
-noinst_HEADERS += src/ecdsa.h
-noinst_HEADERS += src/ecdsa_impl.h
-noinst_HEADERS += src/eckey.h
-noinst_HEADERS += src/eckey_impl.h
-noinst_HEADERS += src/ecmult.h
-noinst_HEADERS += src/ecmult_impl.h
-noinst_HEADERS += src/ecmult_const.h
-noinst_HEADERS += src/ecmult_const_impl.h
-noinst_HEADERS += src/ecmult_gen.h
-noinst_HEADERS += src/ecmult_gen_impl.h
-noinst_HEADERS += src/num.h
-noinst_HEADERS += src/num_impl.h
-noinst_HEADERS += src/field_10x26.h
-noinst_HEADERS += src/field_10x26_impl.h
-noinst_HEADERS += src/field_5x52.h
-noinst_HEADERS += src/field_5x52_impl.h
-noinst_HEADERS += src/field_5x52_int128_impl.h
-noinst_HEADERS += src/field_5x52_asm_impl.h
-noinst_HEADERS += src/java/org_bitcoin_NativeSecp256k1.h
-noinst_HEADERS += src/java/org_bitcoin_Secp256k1Context.h
-noinst_HEADERS += src/util.h
-noinst_HEADERS += src/testrand.h
-noinst_HEADERS += src/testrand_impl.h
-noinst_HEADERS += src/hash.h
-noinst_HEADERS += src/hash_impl.h
-noinst_HEADERS += src/field.h
-noinst_HEADERS += src/field_impl.h
-noinst_HEADERS += src/bench.h
-noinst_HEADERS += contrib/lax_der_parsing.h
-noinst_HEADERS += contrib/lax_der_parsing.c
-noinst_HEADERS += contrib/lax_der_privatekey_parsing.h
-noinst_HEADERS += contrib/lax_der_privatekey_parsing.c
-
-if USE_EXTERNAL_ASM
-COMMON_LIB = libsecp256k1_common.la
-noinst_LTLIBRARIES = $(COMMON_LIB)
-else
-COMMON_LIB =
-endif
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = libsecp256k1.pc
-
-if USE_EXTERNAL_ASM
-if USE_ASM_ARM
-libsecp256k1_common_la_SOURCES = src/asm/field_10x26_arm.s
-endif
-endif
-
-libsecp256k1_la_SOURCES = src/secp256k1.c
-libsecp256k1_la_CPPFLAGS = -DSECP256K1_BUILD -I$(top_srcdir)/include -I$(top_srcdir)/src $(SECP_INCLUDES)
-libsecp256k1_la_LIBADD = $(JNI_LIB) $(SECP_LIBS) $(COMMON_LIB)
-
-libsecp256k1_jni_la_SOURCES = src/java/org_bitcoin_NativeSecp256k1.c src/java/org_bitcoin_Secp256k1Context.c
-libsecp256k1_jni_la_CPPFLAGS = -DSECP256K1_BUILD $(JNI_INCLUDES)
-
-noinst_PROGRAMS =
-if USE_BENCHMARK
-noinst_PROGRAMS += bench_verify bench_sign bench_internal
-bench_verify_SOURCES = src/bench_verify.c
-bench_verify_LDADD = libsecp256k1.la $(SECP_LIBS) $(SECP_TEST_LIBS) $(COMMON_LIB)
-bench_sign_SOURCES = src/bench_sign.c
-bench_sign_LDADD = libsecp256k1.la $(SECP_LIBS) $(SECP_TEST_LIBS) $(COMMON_LIB)
-bench_internal_SOURCES = src/bench_internal.c
-bench_internal_LDADD = $(SECP_LIBS) $(COMMON_LIB)
-bench_internal_CPPFLAGS = -DSECP256K1_BUILD $(SECP_INCLUDES)
-endif
-
-TESTS =
-if USE_TESTS
-noinst_PROGRAMS += tests
-tests_SOURCES = src/tests.c
-tests_CPPFLAGS = -DSECP256K1_BUILD -I$(top_srcdir)/src -I$(top_srcdir)/include $(SECP_INCLUDES) $(SECP_TEST_INCLUDES)
-if !ENABLE_COVERAGE
-tests_CPPFLAGS += -DVERIFY
-endif
-tests_LDADD = $(SECP_LIBS) $(SECP_TEST_LIBS) $(COMMON_LIB)
-tests_LDFLAGS = -static
-TESTS += tests
-endif
-
-if USE_EXHAUSTIVE_TESTS
-noinst_PROGRAMS += exhaustive_tests
-exhaustive_tests_SOURCES = src/tests_exhaustive.c
-exhaustive_tests_CPPFLAGS = -DSECP256K1_BUILD -I$(top_srcdir)/src $(SECP_INCLUDES)
-if !ENABLE_COVERAGE
-exhaustive_tests_CPPFLAGS += -DVERIFY
-endif
-exhaustive_tests_LDADD = $(SECP_LIBS)
-exhaustive_tests_LDFLAGS = -static
-TESTS += exhaustive_tests
-endif
-
-JAVAROOT=src/java
-JAVAORG=org/bitcoin
-JAVA_GUAVA=$(srcdir)/$(JAVAROOT)/guava/guava-18.0.jar
-CLASSPATH_ENV=CLASSPATH=$(JAVA_GUAVA)
-JAVA_FILES= \
- $(JAVAROOT)/$(JAVAORG)/NativeSecp256k1.java \
- $(JAVAROOT)/$(JAVAORG)/NativeSecp256k1Test.java \
- $(JAVAROOT)/$(JAVAORG)/NativeSecp256k1Util.java \
- $(JAVAROOT)/$(JAVAORG)/Secp256k1Context.java
-
-if USE_JNI
-
-$(JAVA_GUAVA):
- @echo Guava is missing. Fetch it via: \
- wget https://search.maven.org/remotecontent?filepath=com/google/guava/guava/18.0/guava-18.0.jar -O $(@)
- @false
-
-.stamp-java: $(JAVA_FILES)
- @echo Compiling $^
- $(AM_V_at)$(CLASSPATH_ENV) javac $^
- @touch $@
-
-if USE_TESTS
-
-check-java: libsecp256k1.la $(JAVA_GUAVA) .stamp-java
- $(AM_V_at)java -Djava.library.path="./:./src:./src/.libs:.libs/" -cp "$(JAVA_GUAVA):$(JAVAROOT)" $(JAVAORG)/NativeSecp256k1Test
-
-endif
-endif
-
-if USE_ECMULT_STATIC_PRECOMPUTATION
-CPPFLAGS_FOR_BUILD +=-I$(top_srcdir)
-CFLAGS_FOR_BUILD += -Wall -Wextra -Wno-unused-function
-
-gen_context_OBJECTS = gen_context.o
-gen_context_BIN = gen_context$(BUILD_EXEEXT)
-gen_%.o: src/gen_%.c
- $(CC_FOR_BUILD) $(CPPFLAGS_FOR_BUILD) $(CFLAGS_FOR_BUILD) -c $< -o $@
-
-$(gen_context_BIN): $(gen_context_OBJECTS)
- $(CC_FOR_BUILD) $^ -o $@
-
-$(libsecp256k1_la_OBJECTS): src/ecmult_static_context.h
-$(tests_OBJECTS): src/ecmult_static_context.h
-$(bench_internal_OBJECTS): src/ecmult_static_context.h
-
-src/ecmult_static_context.h: $(gen_context_BIN)
- ./$(gen_context_BIN)
-
-CLEANFILES = $(gen_context_BIN) src/ecmult_static_context.h $(JAVAROOT)/$(JAVAORG)/*.class .stamp-java
-endif
-
-EXTRA_DIST = autogen.sh src/gen_context.c src/basic-config.h $(JAVA_FILES)
-
-if ENABLE_MODULE_ECDH
-include src/modules/ecdh/Makefile.am.include
-endif
-
-if ENABLE_MODULE_RECOVERY
-include src/modules/recovery/Makefile.am.include
-endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/README.md op-geth/crypto/secp256k1/libsecp256k1/README.md
deleted file mode 100644
index 8cd344ea81232413cf9004bc50dec4ec2fe112a6..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/README.md
+++ /dev/null
@@ -1,61 +0,0 @@
-libsecp256k1
-============
-
-[](https://travis-ci.org/bitcoin-core/secp256k1)
-
-Optimized C library for EC operations on curve secp256k1.
-
-This library is a work in progress and is being used to research best practices. Use at your own risk.
-
-Features:
-* secp256k1 ECDSA signing/verification and key generation.
-* Adding/multiplying private/public keys.
-* Serialization/parsing of private keys, public keys, signatures.
-* Constant time, constant memory access signing and pubkey generation.
-* Derandomized DSA (via RFC6979 or with a caller provided function.)
-* Very efficient implementation.
-
-Implementation details
-----------------------
-
-* General
- * No runtime heap allocation.
- * Extensive testing infrastructure.
- * Structured to facilitate review and analysis.
- * Intended to be portable to any system with a C89 compiler and uint64_t support.
- * Expose only higher level interfaces to minimize the API surface and improve application security. ("Be difficult to use insecurely.")
-* Field operations
- * Optimized implementation of arithmetic modulo the curve's field size (2^256 - 0x1000003D1).
- * Using 5 52-bit limbs (including hand-optimized assembly for x86_64, by Diederik Huys).
- * Using 10 26-bit limbs.
- * Field inverses and square roots using a sliding window over blocks of 1s (by Peter Dettman).
-* Scalar operations
- * Optimized implementation without data-dependent branches of arithmetic modulo the curve's order.
- * Using 4 64-bit limbs (relying on __int128 support in the compiler).
- * Using 8 32-bit limbs.
-* Group operations
- * Point addition formula specifically simplified for the curve equation (y^2 = x^3 + 7).
- * Use addition between points in Jacobian and affine coordinates where possible.
- * Use a unified addition/doubling formula where necessary to avoid data-dependent branches.
- * Point/x comparison without a field inversion by comparison in the Jacobian coordinate space.
-* Point multiplication for verification (a*P + b*G).
- * Use wNAF notation for point multiplicands.
- * Use a much larger window for multiples of G, using precomputed multiples.
- * Use Shamir's trick to do the multiplication with the public key and the generator simultaneously.
- * Optionally (off by default) use secp256k1's efficiently-computable endomorphism to split the P multiplicand into 2 half-sized ones.
-* Point multiplication for signing
- * Use a precomputed table of multiples of powers of 16 multiplied with the generator, so general multiplication becomes a series of additions.
- * Access the table with branch-free conditional moves so memory access is uniform.
- * No data-dependent branches
- * The precomputed tables add and eventually subtract points for which no known scalar (private key) is known, preventing even an attacker with control over the private key used to control the data internally.
-
-Build steps
------------
-
-libsecp256k1 is built using autotools:
-
- $ ./autogen.sh
- $ ./configure
- $ make
- $ ./tests
- $ sudo make install # optional
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/TODO op-geth/crypto/secp256k1/libsecp256k1/TODO
deleted file mode 100644
index a300e1c5eb9b1376c82b1f5d557d56be5708546f..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/TODO
+++ /dev/null
@@ -1,3 +0,0 @@
-* Unit tests for fieldelem/groupelem, including ones intended to
- trigger fieldelem's boundary cases.
-* Complete constant-time operations for signing/keygen
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/autogen.sh op-geth/crypto/secp256k1/libsecp256k1/autogen.sh
deleted file mode 100755
index 65286b93530332340a0c4ec89301a54bff92a35b..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/autogen.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/sh
-set -e
-autoreconf -if --warnings=all
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/build-aux/m4/ax_jni_include_dir.m4 op-geth/crypto/secp256k1/libsecp256k1/build-aux/m4/ax_jni_include_dir.m4
deleted file mode 100644
index 1fc36276144a2fb7740c436bd53f09f42b12daff..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/build-aux/m4/ax_jni_include_dir.m4
+++ /dev/null
@@ -1,140 +0,0 @@
-# ===========================================================================
-# http://www.gnu.org/software/autoconf-archive/ax_jni_include_dir.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-# AX_JNI_INCLUDE_DIR
-#
-# DESCRIPTION
-#
-# AX_JNI_INCLUDE_DIR finds include directories needed for compiling
-# programs using the JNI interface.
-#
-# JNI include directories are usually in the Java distribution. This is
-# deduced from the value of $JAVA_HOME, $JAVAC, or the path to "javac", in
-# that order. When this macro completes, a list of directories is left in
-# the variable JNI_INCLUDE_DIRS.
-#
-# Example usage follows:
-#
-# AX_JNI_INCLUDE_DIR
-#
-# for JNI_INCLUDE_DIR in $JNI_INCLUDE_DIRS
-# do
-# CPPFLAGS="$CPPFLAGS -I$JNI_INCLUDE_DIR"
-# done
-#
-# If you want to force a specific compiler:
-#
-# - at the configure.in level, set JAVAC=yourcompiler before calling
-# AX_JNI_INCLUDE_DIR
-#
-# - at the configure level, setenv JAVAC
-#
-# Note: This macro can work with the autoconf M4 macros for Java programs.
-# This particular macro is not part of the original set of macros.
-#
-# LICENSE
-#
-# Copyright (c) 2008 Don Anderson <dda@sleepycat.com>
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice
-# and this notice are preserved. This file is offered as-is, without any
-# warranty.
-
-#serial 10
-
-AU_ALIAS([AC_JNI_INCLUDE_DIR], [AX_JNI_INCLUDE_DIR])
-AC_DEFUN([AX_JNI_INCLUDE_DIR],[
-
-JNI_INCLUDE_DIRS=""
-
-if test "x$JAVA_HOME" != x; then
- _JTOPDIR="$JAVA_HOME"
-else
- if test "x$JAVAC" = x; then
- JAVAC=javac
- fi
- AC_PATH_PROG([_ACJNI_JAVAC], [$JAVAC], [no])
- if test "x$_ACJNI_JAVAC" = xno; then
- AC_MSG_WARN([cannot find JDK; try setting \$JAVAC or \$JAVA_HOME])
- fi
- _ACJNI_FOLLOW_SYMLINKS("$_ACJNI_JAVAC")
- _JTOPDIR=`echo "$_ACJNI_FOLLOWED" | sed -e 's://*:/:g' -e 's:/[[^/]]*$::'`
-fi
-
-case "$host_os" in
- darwin*) _JTOPDIR=`echo "$_JTOPDIR" | sed -e 's:/[[^/]]*$::'`
- _JINC="$_JTOPDIR/Headers";;
- *) _JINC="$_JTOPDIR/include";;
-esac
-_AS_ECHO_LOG([_JTOPDIR=$_JTOPDIR])
-_AS_ECHO_LOG([_JINC=$_JINC])
-
-# On Mac OS X 10.6.4, jni.h is a symlink:
-# /System/Library/Frameworks/JavaVM.framework/Versions/Current/Headers/jni.h
-# -> ../../CurrentJDK/Headers/jni.h.
-
-AC_CACHE_CHECK(jni headers, ac_cv_jni_header_path,
-[
-if test -f "$_JINC/jni.h"; then
- ac_cv_jni_header_path="$_JINC"
- JNI_INCLUDE_DIRS="$JNI_INCLUDE_DIRS $ac_cv_jni_header_path"
-else
- _JTOPDIR=`echo "$_JTOPDIR" | sed -e 's:/[[^/]]*$::'`
- if test -f "$_JTOPDIR/include/jni.h"; then
- ac_cv_jni_header_path="$_JTOPDIR/include"
- JNI_INCLUDE_DIRS="$JNI_INCLUDE_DIRS $ac_cv_jni_header_path"
- else
- ac_cv_jni_header_path=none
- fi
-fi
-])
-
-
-
-# get the likely subdirectories for system specific java includes
-case "$host_os" in
-bsdi*) _JNI_INC_SUBDIRS="bsdos";;
-darwin*) _JNI_INC_SUBDIRS="darwin";;
-freebsd*) _JNI_INC_SUBDIRS="freebsd";;
-linux*) _JNI_INC_SUBDIRS="linux genunix";;
-osf*) _JNI_INC_SUBDIRS="alpha";;
-solaris*) _JNI_INC_SUBDIRS="solaris";;
-mingw*) _JNI_INC_SUBDIRS="win32";;
-cygwin*) _JNI_INC_SUBDIRS="win32";;
-*) _JNI_INC_SUBDIRS="genunix";;
-esac
-
-if test "x$ac_cv_jni_header_path" != "xnone"; then
- # add any subdirectories that are present
- for JINCSUBDIR in $_JNI_INC_SUBDIRS
- do
- if test -d "$_JTOPDIR/include/$JINCSUBDIR"; then
- JNI_INCLUDE_DIRS="$JNI_INCLUDE_DIRS $_JTOPDIR/include/$JINCSUBDIR"
- fi
- done
-fi
-])
-
-# _ACJNI_FOLLOW_SYMLINKS <path>
-# Follows symbolic links on <path>,
-# finally setting variable _ACJNI_FOLLOWED
-# ----------------------------------------
-AC_DEFUN([_ACJNI_FOLLOW_SYMLINKS],[
-# find the include directory relative to the javac executable
-_cur="$1"
-while ls -ld "$_cur" 2>/dev/null | grep " -> " >/dev/null; do
- AC_MSG_CHECKING([symlink for $_cur])
- _slink=`ls -ld "$_cur" | sed 's/.* -> //'`
- case "$_slink" in
- /*) _cur="$_slink";;
- # 'X' avoids triggering unwanted echo options.
- *) _cur=`echo "X$_cur" | sed -e 's/^X//' -e 's:[[^/]]*$::'`"$_slink";;
- esac
- AC_MSG_RESULT([$_cur])
-done
-_ACJNI_FOLLOWED="$_cur"
-])# _ACJNI
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/build-aux/m4/ax_prog_cc_for_build.m4 op-geth/crypto/secp256k1/libsecp256k1/build-aux/m4/ax_prog_cc_for_build.m4
deleted file mode 100644
index 77fd346a79a6faea6e1c40e34465bb6a5b7f5895..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/build-aux/m4/ax_prog_cc_for_build.m4
+++ /dev/null
@@ -1,125 +0,0 @@
-# ===========================================================================
-# http://www.gnu.org/software/autoconf-archive/ax_prog_cc_for_build.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-# AX_PROG_CC_FOR_BUILD
-#
-# DESCRIPTION
-#
-# This macro searches for a C compiler that generates native executables,
-# that is a C compiler that surely is not a cross-compiler. This can be
-# useful if you have to generate source code at compile-time like for
-# example GCC does.
-#
-# The macro sets the CC_FOR_BUILD and CPP_FOR_BUILD macros to anything
-# needed to compile or link (CC_FOR_BUILD) and preprocess (CPP_FOR_BUILD).
-# The value of these variables can be overridden by the user by specifying
-# a compiler with an environment variable (like you do for standard CC).
-#
-# It also sets BUILD_EXEEXT and BUILD_OBJEXT to the executable and object
-# file extensions for the build platform, and GCC_FOR_BUILD to `yes' if
-# the compiler we found is GCC. All these variables but GCC_FOR_BUILD are
-# substituted in the Makefile.
-#
-# LICENSE
-#
-# Copyright (c) 2008 Paolo Bonzini <bonzini@gnu.org>
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice
-# and this notice are preserved. This file is offered as-is, without any
-# warranty.
-
-#serial 8
-
-AU_ALIAS([AC_PROG_CC_FOR_BUILD], [AX_PROG_CC_FOR_BUILD])
-AC_DEFUN([AX_PROG_CC_FOR_BUILD], [dnl
-AC_REQUIRE([AC_PROG_CC])dnl
-AC_REQUIRE([AC_PROG_CPP])dnl
-AC_REQUIRE([AC_EXEEXT])dnl
-AC_REQUIRE([AC_CANONICAL_HOST])dnl
-
-dnl Use the standard macros, but make them use other variable names
-dnl
-pushdef([ac_cv_prog_CPP], ac_cv_build_prog_CPP)dnl
-pushdef([ac_cv_prog_gcc], ac_cv_build_prog_gcc)dnl
-pushdef([ac_cv_prog_cc_works], ac_cv_build_prog_cc_works)dnl
-pushdef([ac_cv_prog_cc_cross], ac_cv_build_prog_cc_cross)dnl
-pushdef([ac_cv_prog_cc_g], ac_cv_build_prog_cc_g)dnl
-pushdef([ac_cv_exeext], ac_cv_build_exeext)dnl
-pushdef([ac_cv_objext], ac_cv_build_objext)dnl
-pushdef([ac_exeext], ac_build_exeext)dnl
-pushdef([ac_objext], ac_build_objext)dnl
-pushdef([CC], CC_FOR_BUILD)dnl
-pushdef([CPP], CPP_FOR_BUILD)dnl
-pushdef([CFLAGS], CFLAGS_FOR_BUILD)dnl
-pushdef([CPPFLAGS], CPPFLAGS_FOR_BUILD)dnl
-pushdef([LDFLAGS], LDFLAGS_FOR_BUILD)dnl
-pushdef([host], build)dnl
-pushdef([host_alias], build_alias)dnl
-pushdef([host_cpu], build_cpu)dnl
-pushdef([host_vendor], build_vendor)dnl
-pushdef([host_os], build_os)dnl
-pushdef([ac_cv_host], ac_cv_build)dnl
-pushdef([ac_cv_host_alias], ac_cv_build_alias)dnl
-pushdef([ac_cv_host_cpu], ac_cv_build_cpu)dnl
-pushdef([ac_cv_host_vendor], ac_cv_build_vendor)dnl
-pushdef([ac_cv_host_os], ac_cv_build_os)dnl
-pushdef([ac_cpp], ac_build_cpp)dnl
-pushdef([ac_compile], ac_build_compile)dnl
-pushdef([ac_link], ac_build_link)dnl
-
-save_cross_compiling=$cross_compiling
-save_ac_tool_prefix=$ac_tool_prefix
-cross_compiling=no
-ac_tool_prefix=
-
-AC_PROG_CC
-AC_PROG_CPP
-AC_EXEEXT
-
-ac_tool_prefix=$save_ac_tool_prefix
-cross_compiling=$save_cross_compiling
-
-dnl Restore the old definitions
-dnl
-popdef([ac_link])dnl
-popdef([ac_compile])dnl
-popdef([ac_cpp])dnl
-popdef([ac_cv_host_os])dnl
-popdef([ac_cv_host_vendor])dnl
-popdef([ac_cv_host_cpu])dnl
-popdef([ac_cv_host_alias])dnl
-popdef([ac_cv_host])dnl
-popdef([host_os])dnl
-popdef([host_vendor])dnl
-popdef([host_cpu])dnl
-popdef([host_alias])dnl
-popdef([host])dnl
-popdef([LDFLAGS])dnl
-popdef([CPPFLAGS])dnl
-popdef([CFLAGS])dnl
-popdef([CPP])dnl
-popdef([CC])dnl
-popdef([ac_objext])dnl
-popdef([ac_exeext])dnl
-popdef([ac_cv_objext])dnl
-popdef([ac_cv_exeext])dnl
-popdef([ac_cv_prog_cc_g])dnl
-popdef([ac_cv_prog_cc_cross])dnl
-popdef([ac_cv_prog_cc_works])dnl
-popdef([ac_cv_prog_gcc])dnl
-popdef([ac_cv_prog_CPP])dnl
-
-dnl Finally, set Makefile variables
-dnl
-BUILD_EXEEXT=$ac_build_exeext
-BUILD_OBJEXT=$ac_build_objext
-AC_SUBST(BUILD_EXEEXT)dnl
-AC_SUBST(BUILD_OBJEXT)dnl
-AC_SUBST([CFLAGS_FOR_BUILD])dnl
-AC_SUBST([CPPFLAGS_FOR_BUILD])dnl
-AC_SUBST([LDFLAGS_FOR_BUILD])dnl
-])
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/build-aux/m4/bitcoin_secp.m4 op-geth/crypto/secp256k1/libsecp256k1/build-aux/m4/bitcoin_secp.m4
deleted file mode 100644
index b74acb8c138823c67e7fd0a11d059a90bd2551a9..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/build-aux/m4/bitcoin_secp.m4
+++ /dev/null
@@ -1,69 +0,0 @@
-dnl libsecp25k1 helper checks
-AC_DEFUN([SECP_INT128_CHECK],[
-has_int128=$ac_cv_type___int128
-])
-
-dnl escape "$0x" below using the m4 quadrigaph @S|@, and escape it again with a \ for the shell.
-AC_DEFUN([SECP_64BIT_ASM_CHECK],[
-AC_MSG_CHECKING(for x86_64 assembly availability)
-AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
- #include <stdint.h>]],[[
- uint64_t a = 11, tmp;
- __asm__ __volatile__("movq \@S|@0x100000000,%1; mulq %%rsi" : "+a"(a) : "S"(tmp) : "cc", "%rdx");
- ]])],[has_64bit_asm=yes],[has_64bit_asm=no])
-AC_MSG_RESULT([$has_64bit_asm])
-])
-
-dnl
-AC_DEFUN([SECP_OPENSSL_CHECK],[
- has_libcrypto=no
- m4_ifdef([PKG_CHECK_MODULES],[
- PKG_CHECK_MODULES([CRYPTO], [libcrypto], [has_libcrypto=yes],[has_libcrypto=no])
- if test x"$has_libcrypto" = x"yes"; then
- TEMP_LIBS="$LIBS"
- LIBS="$LIBS $CRYPTO_LIBS"
- AC_CHECK_LIB(crypto, main,[AC_DEFINE(HAVE_LIBCRYPTO,1,[Define this symbol if libcrypto is installed])],[has_libcrypto=no])
- LIBS="$TEMP_LIBS"
- fi
- ])
- if test x$has_libcrypto = xno; then
- AC_CHECK_HEADER(openssl/crypto.h,[
- AC_CHECK_LIB(crypto, main,[
- has_libcrypto=yes
- CRYPTO_LIBS=-lcrypto
- AC_DEFINE(HAVE_LIBCRYPTO,1,[Define this symbol if libcrypto is installed])
- ])
- ])
- LIBS=
- fi
-if test x"$has_libcrypto" = x"yes" && test x"$has_openssl_ec" = x; then
- AC_MSG_CHECKING(for EC functions in libcrypto)
- AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
- #include <openssl/ec.h>
- #include <openssl/ecdsa.h>
- #include <openssl/obj_mac.h>]],[[
- EC_KEY *eckey = EC_KEY_new_by_curve_name(NID_secp256k1);
- ECDSA_sign(0, NULL, 0, NULL, NULL, eckey);
- ECDSA_verify(0, NULL, 0, NULL, 0, eckey);
- EC_KEY_free(eckey);
- ECDSA_SIG *sig_openssl;
- sig_openssl = ECDSA_SIG_new();
- (void)sig_openssl->r;
- ECDSA_SIG_free(sig_openssl);
- ]])],[has_openssl_ec=yes],[has_openssl_ec=no])
- AC_MSG_RESULT([$has_openssl_ec])
-fi
-])
-
-dnl
-AC_DEFUN([SECP_GMP_CHECK],[
-if test x"$has_gmp" != x"yes"; then
- CPPFLAGS_TEMP="$CPPFLAGS"
- CPPFLAGS="$GMP_CPPFLAGS $CPPFLAGS"
- LIBS_TEMP="$LIBS"
- LIBS="$GMP_LIBS $LIBS"
- AC_CHECK_HEADER(gmp.h,[AC_CHECK_LIB(gmp, __gmpz_init,[has_gmp=yes; GMP_LIBS="$GMP_LIBS -lgmp"; AC_DEFINE(HAVE_LIBGMP,1,[Define this symbol if libgmp is installed])])])
- CPPFLAGS="$CPPFLAGS_TEMP"
- LIBS="$LIBS_TEMP"
-fi
-])
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/configure.ac op-geth/crypto/secp256k1/libsecp256k1/configure.ac
deleted file mode 100644
index e5fcbcb4edf2ace1c2b8740fc118b1e784f12d5e..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/configure.ac
+++ /dev/null
@@ -1,493 +0,0 @@
-AC_PREREQ([2.60])
-AC_INIT([libsecp256k1],[0.1])
-AC_CONFIG_AUX_DIR([build-aux])
-AC_CONFIG_MACRO_DIR([build-aux/m4])
-AC_CANONICAL_HOST
-AH_TOP([#ifndef LIBSECP256K1_CONFIG_H])
-AH_TOP([#define LIBSECP256K1_CONFIG_H])
-AH_BOTTOM([#endif /*LIBSECP256K1_CONFIG_H*/])
-AM_INIT_AUTOMAKE([foreign subdir-objects])
-LT_INIT
-
-dnl make the compilation flags quiet unless V=1 is used
-m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
-
-PKG_PROG_PKG_CONFIG
-
-AC_PATH_TOOL(AR, ar)
-AC_PATH_TOOL(RANLIB, ranlib)
-AC_PATH_TOOL(STRIP, strip)
-AX_PROG_CC_FOR_BUILD
-
-if test "x$CFLAGS" = "x"; then
- CFLAGS="-g"
-fi
-
-AM_PROG_CC_C_O
-
-AC_PROG_CC_C89
-if test x"$ac_cv_prog_cc_c89" = x"no"; then
- AC_MSG_ERROR([c89 compiler support required])
-fi
-AM_PROG_AS
-
-case $host_os in
- *darwin*)
- if test x$cross_compiling != xyes; then
- AC_PATH_PROG([BREW],brew,)
- if test x$BREW != x; then
- dnl These Homebrew packages may be keg-only, meaning that they won't be found
- dnl in expected paths because they may conflict with system files. Ask
- dnl Homebrew where each one is located, then adjust paths accordingly.
-
- openssl_prefix=`$BREW --prefix openssl 2>/dev/null`
- gmp_prefix=`$BREW --prefix gmp 2>/dev/null`
- if test x$openssl_prefix != x; then
- PKG_CONFIG_PATH="$openssl_prefix/lib/pkgconfig:$PKG_CONFIG_PATH"
- export PKG_CONFIG_PATH
- fi
- if test x$gmp_prefix != x; then
- GMP_CPPFLAGS="-I$gmp_prefix/include"
- GMP_LIBS="-L$gmp_prefix/lib"
- fi
- else
- AC_PATH_PROG([PORT],port,)
- dnl if homebrew isn't installed and macports is, add the macports default paths
- dnl as a last resort.
- if test x$PORT != x; then
- CPPFLAGS="$CPPFLAGS -isystem /opt/local/include"
- LDFLAGS="$LDFLAGS -L/opt/local/lib"
- fi
- fi
- fi
- ;;
-esac
-
-CFLAGS="$CFLAGS -W"
-
-warn_CFLAGS="-std=c89 -pedantic -Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes -Wno-unused-function -Wno-long-long -Wno-overlength-strings"
-saved_CFLAGS="$CFLAGS"
-CFLAGS="$CFLAGS $warn_CFLAGS"
-AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}])
-AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
- [ AC_MSG_RESULT([yes]) ],
- [ AC_MSG_RESULT([no])
- CFLAGS="$saved_CFLAGS"
- ])
-
-saved_CFLAGS="$CFLAGS"
-CFLAGS="$CFLAGS -fvisibility=hidden"
-AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden])
-AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
- [ AC_MSG_RESULT([yes]) ],
- [ AC_MSG_RESULT([no])
- CFLAGS="$saved_CFLAGS"
- ])
-
-AC_ARG_ENABLE(benchmark,
- AS_HELP_STRING([--enable-benchmark],[compile benchmark (default is no)]),
- [use_benchmark=$enableval],
- [use_benchmark=no])
-
-AC_ARG_ENABLE(coverage,
- AS_HELP_STRING([--enable-coverage],[enable compiler flags to support kcov coverage analysis]),
- [enable_coverage=$enableval],
- [enable_coverage=no])
-
-AC_ARG_ENABLE(tests,
- AS_HELP_STRING([--enable-tests],[compile tests (default is yes)]),
- [use_tests=$enableval],
- [use_tests=yes])
-
-AC_ARG_ENABLE(openssl_tests,
- AS_HELP_STRING([--enable-openssl-tests],[enable OpenSSL tests, if OpenSSL is available (default is auto)]),
- [enable_openssl_tests=$enableval],
- [enable_openssl_tests=auto])
-
-AC_ARG_ENABLE(experimental,
- AS_HELP_STRING([--enable-experimental],[allow experimental configure options (default is no)]),
- [use_experimental=$enableval],
- [use_experimental=no])
-
-AC_ARG_ENABLE(exhaustive_tests,
- AS_HELP_STRING([--enable-exhaustive-tests],[compile exhaustive tests (default is yes)]),
- [use_exhaustive_tests=$enableval],
- [use_exhaustive_tests=yes])
-
-AC_ARG_ENABLE(endomorphism,
- AS_HELP_STRING([--enable-endomorphism],[enable endomorphism (default is no)]),
- [use_endomorphism=$enableval],
- [use_endomorphism=no])
-
-AC_ARG_ENABLE(ecmult_static_precomputation,
- AS_HELP_STRING([--enable-ecmult-static-precomputation],[enable precomputed ecmult table for signing (default is yes)]),
- [use_ecmult_static_precomputation=$enableval],
- [use_ecmult_static_precomputation=auto])
-
-AC_ARG_ENABLE(module_ecdh,
- AS_HELP_STRING([--enable-module-ecdh],[enable ECDH shared secret computation (experimental)]),
- [enable_module_ecdh=$enableval],
- [enable_module_ecdh=no])
-
-AC_ARG_ENABLE(module_recovery,
- AS_HELP_STRING([--enable-module-recovery],[enable ECDSA pubkey recovery module (default is no)]),
- [enable_module_recovery=$enableval],
- [enable_module_recovery=no])
-
-AC_ARG_ENABLE(jni,
- AS_HELP_STRING([--enable-jni],[enable libsecp256k1_jni (default is auto)]),
- [use_jni=$enableval],
- [use_jni=auto])
-
-AC_ARG_WITH([field], [AS_HELP_STRING([--with-field=64bit|32bit|auto],
-[Specify Field Implementation. Default is auto])],[req_field=$withval], [req_field=auto])
-
-AC_ARG_WITH([bignum], [AS_HELP_STRING([--with-bignum=gmp|no|auto],
-[Specify Bignum Implementation. Default is auto])],[req_bignum=$withval], [req_bignum=auto])
-
-AC_ARG_WITH([scalar], [AS_HELP_STRING([--with-scalar=64bit|32bit|auto],
-[Specify scalar implementation. Default is auto])],[req_scalar=$withval], [req_scalar=auto])
-
-AC_ARG_WITH([asm], [AS_HELP_STRING([--with-asm=x86_64|arm|no|auto]
-[Specify assembly optimizations to use. Default is auto (experimental: arm)])],[req_asm=$withval], [req_asm=auto])
-
-AC_CHECK_TYPES([__int128])
-
-AC_MSG_CHECKING([for __builtin_expect])
-AC_COMPILE_IFELSE([AC_LANG_SOURCE([[void myfunc() {__builtin_expect(0,0);}]])],
- [ AC_MSG_RESULT([yes]);AC_DEFINE(HAVE_BUILTIN_EXPECT,1,[Define this symbol if __builtin_expect is available]) ],
- [ AC_MSG_RESULT([no])
- ])
-
-if test x"$enable_coverage" = x"yes"; then
- AC_DEFINE(COVERAGE, 1, [Define this symbol to compile out all VERIFY code])
- CFLAGS="$CFLAGS -O0 --coverage"
- LDFLAGS="--coverage"
-else
- CFLAGS="$CFLAGS -O3"
-fi
-
-if test x"$use_ecmult_static_precomputation" != x"no"; then
- save_cross_compiling=$cross_compiling
- cross_compiling=no
- TEMP_CC="$CC"
- CC="$CC_FOR_BUILD"
- AC_MSG_CHECKING([native compiler: ${CC_FOR_BUILD}])
- AC_RUN_IFELSE(
- [AC_LANG_PROGRAM([], [return 0])],
- [working_native_cc=yes],
- [working_native_cc=no],[dnl])
- CC="$TEMP_CC"
- cross_compiling=$save_cross_compiling
-
- if test x"$working_native_cc" = x"no"; then
- set_precomp=no
- if test x"$use_ecmult_static_precomputation" = x"yes"; then
- AC_MSG_ERROR([${CC_FOR_BUILD} does not produce working binaries. Please set CC_FOR_BUILD])
- else
- AC_MSG_RESULT([${CC_FOR_BUILD} does not produce working binaries. Please set CC_FOR_BUILD])
- fi
- else
- AC_MSG_RESULT([ok])
- set_precomp=yes
- fi
-else
- set_precomp=no
-fi
-
-if test x"$req_asm" = x"auto"; then
- SECP_64BIT_ASM_CHECK
- if test x"$has_64bit_asm" = x"yes"; then
- set_asm=x86_64
- fi
- if test x"$set_asm" = x; then
- set_asm=no
- fi
-else
- set_asm=$req_asm
- case $set_asm in
- x86_64)
- SECP_64BIT_ASM_CHECK
- if test x"$has_64bit_asm" != x"yes"; then
- AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
- fi
- ;;
- arm)
- ;;
- no)
- ;;
- *)
- AC_MSG_ERROR([invalid assembly optimization selection])
- ;;
- esac
-fi
-
-if test x"$req_field" = x"auto"; then
- if test x"set_asm" = x"x86_64"; then
- set_field=64bit
- fi
- if test x"$set_field" = x; then
- SECP_INT128_CHECK
- if test x"$has_int128" = x"yes"; then
- set_field=64bit
- fi
- fi
- if test x"$set_field" = x; then
- set_field=32bit
- fi
-else
- set_field=$req_field
- case $set_field in
- 64bit)
- if test x"$set_asm" != x"x86_64"; then
- SECP_INT128_CHECK
- if test x"$has_int128" != x"yes"; then
- AC_MSG_ERROR([64bit field explicitly requested but neither __int128 support or x86_64 assembly available])
- fi
- fi
- ;;
- 32bit)
- ;;
- *)
- AC_MSG_ERROR([invalid field implementation selection])
- ;;
- esac
-fi
-
-if test x"$req_scalar" = x"auto"; then
- SECP_INT128_CHECK
- if test x"$has_int128" = x"yes"; then
- set_scalar=64bit
- fi
- if test x"$set_scalar" = x; then
- set_scalar=32bit
- fi
-else
- set_scalar=$req_scalar
- case $set_scalar in
- 64bit)
- SECP_INT128_CHECK
- if test x"$has_int128" != x"yes"; then
- AC_MSG_ERROR([64bit scalar explicitly requested but __int128 support not available])
- fi
- ;;
- 32bit)
- ;;
- *)
- AC_MSG_ERROR([invalid scalar implementation selected])
- ;;
- esac
-fi
-
-if test x"$req_bignum" = x"auto"; then
- SECP_GMP_CHECK
- if test x"$has_gmp" = x"yes"; then
- set_bignum=gmp
- fi
-
- if test x"$set_bignum" = x; then
- set_bignum=no
- fi
-else
- set_bignum=$req_bignum
- case $set_bignum in
- gmp)
- SECP_GMP_CHECK
- if test x"$has_gmp" != x"yes"; then
- AC_MSG_ERROR([gmp bignum explicitly requested but libgmp not available])
- fi
- ;;
- no)
- ;;
- *)
- AC_MSG_ERROR([invalid bignum implementation selection])
- ;;
- esac
-fi
-
-# select assembly optimization
-use_external_asm=no
-
-case $set_asm in
-x86_64)
- AC_DEFINE(USE_ASM_X86_64, 1, [Define this symbol to enable x86_64 assembly optimizations])
- ;;
-arm)
- use_external_asm=yes
- ;;
-no)
- ;;
-*)
- AC_MSG_ERROR([invalid assembly optimizations])
- ;;
-esac
-
-# select field implementation
-case $set_field in
-64bit)
- AC_DEFINE(USE_FIELD_5X52, 1, [Define this symbol to use the FIELD_5X52 implementation])
- ;;
-32bit)
- AC_DEFINE(USE_FIELD_10X26, 1, [Define this symbol to use the FIELD_10X26 implementation])
- ;;
-*)
- AC_MSG_ERROR([invalid field implementation])
- ;;
-esac
-
-# select bignum implementation
-case $set_bignum in
-gmp)
- AC_DEFINE(HAVE_LIBGMP, 1, [Define this symbol if libgmp is installed])
- AC_DEFINE(USE_NUM_GMP, 1, [Define this symbol to use the gmp implementation for num])
- AC_DEFINE(USE_FIELD_INV_NUM, 1, [Define this symbol to use the num-based field inverse implementation])
- AC_DEFINE(USE_SCALAR_INV_NUM, 1, [Define this symbol to use the num-based scalar inverse implementation])
- ;;
-no)
- AC_DEFINE(USE_NUM_NONE, 1, [Define this symbol to use no num implementation])
- AC_DEFINE(USE_FIELD_INV_BUILTIN, 1, [Define this symbol to use the native field inverse implementation])
- AC_DEFINE(USE_SCALAR_INV_BUILTIN, 1, [Define this symbol to use the native scalar inverse implementation])
- ;;
-*)
- AC_MSG_ERROR([invalid bignum implementation])
- ;;
-esac
-
-#select scalar implementation
-case $set_scalar in
-64bit)
- AC_DEFINE(USE_SCALAR_4X64, 1, [Define this symbol to use the 4x64 scalar implementation])
- ;;
-32bit)
- AC_DEFINE(USE_SCALAR_8X32, 1, [Define this symbol to use the 8x32 scalar implementation])
- ;;
-*)
- AC_MSG_ERROR([invalid scalar implementation])
- ;;
-esac
-
-if test x"$use_tests" = x"yes"; then
- SECP_OPENSSL_CHECK
- if test x"$has_openssl_ec" = x"yes"; then
- if test x"$enable_openssl_tests" != x"no"; then
- AC_DEFINE(ENABLE_OPENSSL_TESTS, 1, [Define this symbol if OpenSSL EC functions are available])
- SECP_TEST_INCLUDES="$SSL_CFLAGS $CRYPTO_CFLAGS"
- SECP_TEST_LIBS="$CRYPTO_LIBS"
-
- case $host in
- *mingw*)
- SECP_TEST_LIBS="$SECP_TEST_LIBS -lgdi32"
- ;;
- esac
- fi
- else
- if test x"$enable_openssl_tests" = x"yes"; then
- AC_MSG_ERROR([OpenSSL tests requested but OpenSSL with EC support is not available])
- fi
- fi
-else
- if test x"$enable_openssl_tests" = x"yes"; then
- AC_MSG_ERROR([OpenSSL tests requested but tests are not enabled])
- fi
-fi
-
-if test x"$use_jni" != x"no"; then
- AX_JNI_INCLUDE_DIR
- have_jni_dependencies=yes
- if test x"$enable_module_ecdh" = x"no"; then
- have_jni_dependencies=no
- fi
- if test "x$JNI_INCLUDE_DIRS" = "x"; then
- have_jni_dependencies=no
- fi
- if test "x$have_jni_dependencies" = "xno"; then
- if test x"$use_jni" = x"yes"; then
- AC_MSG_ERROR([jni support explicitly requested but headers/dependencies were not found. Enable ECDH and try again.])
- fi
- AC_MSG_WARN([jni headers/dependencies not found. jni support disabled])
- use_jni=no
- else
- use_jni=yes
- for JNI_INCLUDE_DIR in $JNI_INCLUDE_DIRS; do
- JNI_INCLUDES="$JNI_INCLUDES -I$JNI_INCLUDE_DIR"
- done
- fi
-fi
-
-if test x"$set_bignum" = x"gmp"; then
- SECP_LIBS="$SECP_LIBS $GMP_LIBS"
- SECP_INCLUDES="$SECP_INCLUDES $GMP_CPPFLAGS"
-fi
-
-if test x"$use_endomorphism" = x"yes"; then
- AC_DEFINE(USE_ENDOMORPHISM, 1, [Define this symbol to use endomorphism optimization])
-fi
-
-if test x"$set_precomp" = x"yes"; then
- AC_DEFINE(USE_ECMULT_STATIC_PRECOMPUTATION, 1, [Define this symbol to use a statically generated ecmult table])
-fi
-
-if test x"$enable_module_ecdh" = x"yes"; then
- AC_DEFINE(ENABLE_MODULE_ECDH, 1, [Define this symbol to enable the ECDH module])
-fi
-
-if test x"$enable_module_recovery" = x"yes"; then
- AC_DEFINE(ENABLE_MODULE_RECOVERY, 1, [Define this symbol to enable the ECDSA pubkey recovery module])
-fi
-
-AC_C_BIGENDIAN()
-
-if test x"$use_external_asm" = x"yes"; then
- AC_DEFINE(USE_EXTERNAL_ASM, 1, [Define this symbol if an external (non-inline) assembly implementation is used])
-fi
-
-AC_MSG_NOTICE([Using static precomputation: $set_precomp])
-AC_MSG_NOTICE([Using assembly optimizations: $set_asm])
-AC_MSG_NOTICE([Using field implementation: $set_field])
-AC_MSG_NOTICE([Using bignum implementation: $set_bignum])
-AC_MSG_NOTICE([Using scalar implementation: $set_scalar])
-AC_MSG_NOTICE([Using endomorphism optimizations: $use_endomorphism])
-AC_MSG_NOTICE([Building for coverage analysis: $enable_coverage])
-AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
-AC_MSG_NOTICE([Building ECDSA pubkey recovery module: $enable_module_recovery])
-AC_MSG_NOTICE([Using jni: $use_jni])
-
-if test x"$enable_experimental" = x"yes"; then
- AC_MSG_NOTICE([******])
- AC_MSG_NOTICE([WARNING: experimental build])
- AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
- AC_MSG_NOTICE([Building ECDH module: $enable_module_ecdh])
- AC_MSG_NOTICE([******])
-else
- if test x"$enable_module_ecdh" = x"yes"; then
- AC_MSG_ERROR([ECDH module is experimental. Use --enable-experimental to allow.])
- fi
- if test x"$set_asm" = x"arm"; then
- AC_MSG_ERROR([ARM assembly optimization is experimental. Use --enable-experimental to allow.])
- fi
-fi
-
-AC_CONFIG_HEADERS([src/libsecp256k1-config.h])
-AC_CONFIG_FILES([Makefile libsecp256k1.pc])
-AC_SUBST(JNI_INCLUDES)
-AC_SUBST(SECP_INCLUDES)
-AC_SUBST(SECP_LIBS)
-AC_SUBST(SECP_TEST_LIBS)
-AC_SUBST(SECP_TEST_INCLUDES)
-AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
-AM_CONDITIONAL([USE_TESTS], [test x"$use_tests" != x"no"])
-AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$use_exhaustive_tests" != x"no"])
-AM_CONDITIONAL([USE_BENCHMARK], [test x"$use_benchmark" = x"yes"])
-AM_CONDITIONAL([USE_ECMULT_STATIC_PRECOMPUTATION], [test x"$set_precomp" = x"yes"])
-AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
-AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
-AM_CONDITIONAL([USE_JNI], [test x"$use_jni" == x"yes"])
-AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$use_external_asm" = x"yes"])
-AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm"])
-
-dnl make sure nothing new is exported so that we don't break the cache
-PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
-unset PKG_CONFIG_PATH
-PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"
-
-AC_OUTPUT
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/contrib/dummy.go op-geth/crypto/secp256k1/libsecp256k1/contrib/dummy.go
deleted file mode 100644
index 2c946210c54d3776fa19fff82213747179aa9fd6..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/contrib/dummy.go
+++ /dev/null
@@ -1,8 +0,0 @@
-//go:build dummy
-// +build dummy
-
-// Package c contains only a C file.
-//
-// This Go file is part of a workaround for `go mod vendor`.
-// Please see the file crypto/secp256k1/dummy.go for more information.
-package contrib
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/contrib/lax_der_parsing.c op-geth/crypto/secp256k1/libsecp256k1/contrib/lax_der_parsing.c
deleted file mode 100644
index 5b141a99481c71f18bffe38e71a763443b14ef4e..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/contrib/lax_der_parsing.c
+++ /dev/null
@@ -1,150 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#include <string.h>
-#include <secp256k1.h>
-
-#include "lax_der_parsing.h"
-
-int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
- size_t rpos, rlen, spos, slen;
- size_t pos = 0;
- size_t lenbyte;
- unsigned char tmpsig[64] = {0};
- int overflow = 0;
-
- /* Hack to initialize sig with a correctly-parsed but invalid signature. */
- secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
-
- /* Sequence tag byte */
- if (pos == inputlen || input[pos] != 0x30) {
- return 0;
- }
- pos++;
-
- /* Sequence length bytes */
- if (pos == inputlen) {
- return 0;
- }
- lenbyte = input[pos++];
- if (lenbyte & 0x80) {
- lenbyte -= 0x80;
- if (pos + lenbyte > inputlen) {
- return 0;
- }
- pos += lenbyte;
- }
-
- /* Integer tag byte for R */
- if (pos == inputlen || input[pos] != 0x02) {
- return 0;
- }
- pos++;
-
- /* Integer length for R */
- if (pos == inputlen) {
- return 0;
- }
- lenbyte = input[pos++];
- if (lenbyte & 0x80) {
- lenbyte -= 0x80;
- if (pos + lenbyte > inputlen) {
- return 0;
- }
- while (lenbyte > 0 && input[pos] == 0) {
- pos++;
- lenbyte--;
- }
- if (lenbyte >= sizeof(size_t)) {
- return 0;
- }
- rlen = 0;
- while (lenbyte > 0) {
- rlen = (rlen << 8) + input[pos];
- pos++;
- lenbyte--;
- }
- } else {
- rlen = lenbyte;
- }
- if (rlen > inputlen - pos) {
- return 0;
- }
- rpos = pos;
- pos += rlen;
-
- /* Integer tag byte for S */
- if (pos == inputlen || input[pos] != 0x02) {
- return 0;
- }
- pos++;
-
- /* Integer length for S */
- if (pos == inputlen) {
- return 0;
- }
- lenbyte = input[pos++];
- if (lenbyte & 0x80) {
- lenbyte -= 0x80;
- if (pos + lenbyte > inputlen) {
- return 0;
- }
- while (lenbyte > 0 && input[pos] == 0) {
- pos++;
- lenbyte--;
- }
- if (lenbyte >= sizeof(size_t)) {
- return 0;
- }
- slen = 0;
- while (lenbyte > 0) {
- slen = (slen << 8) + input[pos];
- pos++;
- lenbyte--;
- }
- } else {
- slen = lenbyte;
- }
- if (slen > inputlen - pos) {
- return 0;
- }
- spos = pos;
- pos += slen;
-
- /* Ignore leading zeroes in R */
- while (rlen > 0 && input[rpos] == 0) {
- rlen--;
- rpos++;
- }
- /* Copy R value */
- if (rlen > 32) {
- overflow = 1;
- } else {
- memcpy(tmpsig + 32 - rlen, input + rpos, rlen);
- }
-
- /* Ignore leading zeroes in S */
- while (slen > 0 && input[spos] == 0) {
- slen--;
- spos++;
- }
- /* Copy S value */
- if (slen > 32) {
- overflow = 1;
- } else {
- memcpy(tmpsig + 64 - slen, input + spos, slen);
- }
-
- if (!overflow) {
- overflow = !secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
- }
- if (overflow) {
- memset(tmpsig, 0, 64);
- secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
- }
- return 1;
-}
-
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/contrib/lax_der_parsing.h op-geth/crypto/secp256k1/libsecp256k1/contrib/lax_der_parsing.h
deleted file mode 100644
index 6d27871a7ccda3dfc1d34e051a345205522a172f..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/contrib/lax_der_parsing.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-/****
- * Please do not link this file directly. It is not part of the libsecp256k1
- * project and does not promise any stability in its API, functionality or
- * presence. Projects which use this code should instead copy this header
- * and its accompanying .c file directly into their codebase.
- ****/
-
-/* This file defines a function that parses DER with various errors and
- * violations. This is not a part of the library itself, because the allowed
- * violations are chosen arbitrarily and do not follow or establish any
- * standard.
- *
- * In many places it matters that different implementations do not only accept
- * the same set of valid signatures, but also reject the same set of signatures.
- * The only means to accomplish that is by strictly obeying a standard, and not
- * accepting anything else.
- *
- * Nonetheless, sometimes there is a need for compatibility with systems that
- * use signatures which do not strictly obey DER. The snippet below shows how
- * certain violations are easily supported. You may need to adapt it.
- *
- * Do not use this for new systems. Use well-defined DER or compact signatures
- * instead if you have the choice (see secp256k1_ecdsa_signature_parse_der and
- * secp256k1_ecdsa_signature_parse_compact).
- *
- * The supported violations are:
- * - All numbers are parsed as nonnegative integers, even though X.609-0207
- * section 8.3.3 specifies that integers are always encoded as two's
- * complement.
- * - Integers can have length 0, even though section 8.3.1 says they can't.
- * - Integers with overly long padding are accepted, violation section
- * 8.3.2.
- * - 127-byte long length descriptors are accepted, even though section
- * 8.1.3.5.c says that they are not.
- * - Trailing garbage data inside or after the signature is ignored.
- * - The length descriptor of the sequence is ignored.
- *
- * Compared to for example OpenSSL, many violations are NOT supported:
- * - Using overly long tag descriptors for the sequence or integers inside,
- * violating section 8.1.2.2.
- * - Encoding primitive integers as constructed values, violating section
- * 8.3.1.
- */
-
-#ifndef _SECP256K1_CONTRIB_LAX_DER_PARSING_H_
-#define _SECP256K1_CONTRIB_LAX_DER_PARSING_H_
-
-#include <secp256k1.h>
-
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-/** Parse a signature in "lax DER" format
- *
- * Returns: 1 when the signature could be parsed, 0 otherwise.
- * Args: ctx: a secp256k1 context object
- * Out: sig: a pointer to a signature object
- * In: input: a pointer to the signature to be parsed
- * inputlen: the length of the array pointed to be input
- *
- * This function will accept any valid DER encoded signature, even if the
- * encoded numbers are out of range. In addition, it will accept signatures
- * which violate the DER spec in various ways. Its purpose is to allow
- * validation of the Bitcoin blockchain, which includes non-DER signatures
- * from before the network rules were updated to enforce DER. Note that
- * the set of supported violations is a strict subset of what OpenSSL will
- * accept.
- *
- * After the call, sig will always be initialized. If parsing failed or the
- * encoded numbers are out of range, signature validation with it is
- * guaranteed to fail for every message and public key.
- */
-int ecdsa_signature_parse_der_lax(
- const secp256k1_context* ctx,
- secp256k1_ecdsa_signature* sig,
- const unsigned char *input,
- size_t inputlen
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/contrib/lax_der_privatekey_parsing.c op-geth/crypto/secp256k1/libsecp256k1/contrib/lax_der_privatekey_parsing.c
deleted file mode 100644
index c2e63b4b8d7b379543dcee8ba9b0e4bdc957dc0a..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/contrib/lax_der_privatekey_parsing.c
+++ /dev/null
@@ -1,113 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014, 2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#include <string.h>
-#include <secp256k1.h>
-
-#include "lax_der_privatekey_parsing.h"
-
-int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *out32, const unsigned char *privkey, size_t privkeylen) {
- const unsigned char *end = privkey + privkeylen;
- int lenb = 0;
- int len = 0;
- memset(out32, 0, 32);
- /* sequence header */
- if (end < privkey+1 || *privkey != 0x30) {
- return 0;
- }
- privkey++;
- /* sequence length constructor */
- if (end < privkey+1 || !(*privkey & 0x80)) {
- return 0;
- }
- lenb = *privkey & ~0x80; privkey++;
- if (lenb < 1 || lenb > 2) {
- return 0;
- }
- if (end < privkey+lenb) {
- return 0;
- }
- /* sequence length */
- len = privkey[lenb-1] | (lenb > 1 ? privkey[lenb-2] << 8 : 0);
- privkey += lenb;
- if (end < privkey+len) {
- return 0;
- }
- /* sequence element 0: version number (=1) */
- if (end < privkey+3 || privkey[0] != 0x02 || privkey[1] != 0x01 || privkey[2] != 0x01) {
- return 0;
- }
- privkey += 3;
- /* sequence element 1: octet string, up to 32 bytes */
- if (end < privkey+2 || privkey[0] != 0x04 || privkey[1] > 0x20 || end < privkey+2+privkey[1]) {
- return 0;
- }
- memcpy(out32 + 32 - privkey[1], privkey + 2, privkey[1]);
- if (!secp256k1_ec_seckey_verify(ctx, out32)) {
- memset(out32, 0, 32);
- return 0;
- }
- return 1;
-}
-
-int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *privkey, size_t *privkeylen, const unsigned char *key32, int compressed) {
- secp256k1_pubkey pubkey;
- size_t pubkeylen = 0;
- if (!secp256k1_ec_pubkey_create(ctx, &pubkey, key32)) {
- *privkeylen = 0;
- return 0;
- }
- if (compressed) {
- static const unsigned char begin[] = {
- 0x30,0x81,0xD3,0x02,0x01,0x01,0x04,0x20
- };
- static const unsigned char middle[] = {
- 0xA0,0x81,0x85,0x30,0x81,0x82,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
- 0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
- 0x21,0x02,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
- 0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
- 0x17,0x98,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
- 0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x24,0x03,0x22,0x00
- };
- unsigned char *ptr = privkey;
- memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
- memcpy(ptr, key32, 32); ptr += 32;
- memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
- pubkeylen = 33;
- secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
- ptr += pubkeylen;
- *privkeylen = ptr - privkey;
- } else {
- static const unsigned char begin[] = {
- 0x30,0x82,0x01,0x13,0x02,0x01,0x01,0x04,0x20
- };
- static const unsigned char middle[] = {
- 0xA0,0x81,0xA5,0x30,0x81,0xA2,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
- 0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
- 0x41,0x04,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
- 0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
- 0x17,0x98,0x48,0x3A,0xDA,0x77,0x26,0xA3,0xC4,0x65,0x5D,0xA4,0xFB,0xFC,0x0E,0x11,
- 0x08,0xA8,0xFD,0x17,0xB4,0x48,0xA6,0x85,0x54,0x19,0x9C,0x47,0xD0,0x8F,0xFB,0x10,
- 0xD4,0xB8,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
- 0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x44,0x03,0x42,0x00
- };
- unsigned char *ptr = privkey;
- memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
- memcpy(ptr, key32, 32); ptr += 32;
- memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
- pubkeylen = 65;
- secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
- ptr += pubkeylen;
- *privkeylen = ptr - privkey;
- }
- return 1;
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/contrib/lax_der_privatekey_parsing.h op-geth/crypto/secp256k1/libsecp256k1/contrib/lax_der_privatekey_parsing.h
deleted file mode 100644
index 2fd088f8abf1393a0ca49542f262a81d8d6669ab..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/contrib/lax_der_privatekey_parsing.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014, 2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-/****
- * Please do not link this file directly. It is not part of the libsecp256k1
- * project and does not promise any stability in its API, functionality or
- * presence. Projects which use this code should instead copy this header
- * and its accompanying .c file directly into their codebase.
- ****/
-
-/* This file contains code snippets that parse DER private keys with
- * various errors and violations. This is not a part of the library
- * itself, because the allowed violations are chosen arbitrarily and
- * do not follow or establish any standard.
- *
- * It also contains code to serialize private keys in a compatible
- * manner.
- *
- * These functions are meant for compatibility with applications
- * that require BER encoded keys. When working with secp256k1-specific
- * code, the simple 32-byte private keys normally used by the
- * library are sufficient.
- */
-
-#ifndef _SECP256K1_CONTRIB_BER_PRIVATEKEY_H_
-#define _SECP256K1_CONTRIB_BER_PRIVATEKEY_H_
-
-#include <secp256k1.h>
-
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-/** Export a private key in DER format.
- *
- * Returns: 1 if the private key was valid.
- * Args: ctx: pointer to a context object, initialized for signing (cannot
- * be NULL)
- * Out: privkey: pointer to an array for storing the private key in BER.
- * Should have space for 279 bytes, and cannot be NULL.
- * privkeylen: Pointer to an int where the length of the private key in
- * privkey will be stored.
- * In: seckey: pointer to a 32-byte secret key to export.
- * compressed: 1 if the key should be exported in
- * compressed format, 0 otherwise
- *
- * This function is purely meant for compatibility with applications that
- * require BER encoded keys. When working with secp256k1-specific code, the
- * simple 32-byte private keys are sufficient.
- *
- * Note that this function does not guarantee correct DER output. It is
- * guaranteed to be parsable by secp256k1_ec_privkey_import_der
- */
-SECP256K1_WARN_UNUSED_RESULT int ec_privkey_export_der(
- const secp256k1_context* ctx,
- unsigned char *privkey,
- size_t *privkeylen,
- const unsigned char *seckey,
- int compressed
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Import a private key in DER format.
- * Returns: 1 if a private key was extracted.
- * Args: ctx: pointer to a context object (cannot be NULL).
- * Out: seckey: pointer to a 32-byte array for storing the private key.
- * (cannot be NULL).
- * In: privkey: pointer to a private key in DER format (cannot be NULL).
- * privkeylen: length of the DER private key pointed to be privkey.
- *
- * This function will accept more than just strict DER, and even allow some BER
- * violations. The public key stored inside the DER-encoded private key is not
- * verified for correctness, nor are the curve parameters. Use this function
- * only if you know in advance it is supposed to contain a secp256k1 private
- * key.
- */
-SECP256K1_WARN_UNUSED_RESULT int ec_privkey_import_der(
- const secp256k1_context* ctx,
- unsigned char *seckey,
- const unsigned char *privkey,
- size_t privkeylen
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/dummy.go op-geth/crypto/secp256k1/libsecp256k1/dummy.go
deleted file mode 100644
index 04bbe3d76eccd7c3a158b161f4121b49d379330c..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/dummy.go
+++ /dev/null
@@ -1,8 +0,0 @@
-//go:build dummy
-// +build dummy
-
-// Package c contains only a C file.
-//
-// This Go file is part of a workaround for `go mod vendor`.
-// Please see the file crypto/secp256k1/dummy.go for more information.
-package libsecp256k1
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/include/dummy.go op-geth/crypto/secp256k1/libsecp256k1/include/dummy.go
deleted file mode 100644
index 64c71b8451d8703435cabf6b1c012621012720a1..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/include/dummy.go
+++ /dev/null
@@ -1,8 +0,0 @@
-//go:build dummy
-// +build dummy
-
-// Package c contains only a C file.
-//
-// This Go file is part of a workaround for `go mod vendor`.
-// Please see the file crypto/secp256k1/dummy.go for more information.
-package include
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/include/secp256k1.h op-geth/crypto/secp256k1/libsecp256k1/include/secp256k1.h
deleted file mode 100644
index f268e309d0bf5d0db21bc61224bb798aba14dbf0..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/include/secp256k1.h
+++ /dev/null
@@ -1,577 +0,0 @@
-#ifndef _SECP256K1_
-# define _SECP256K1_
-
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-#include <stddef.h>
-
-/* These rules specify the order of arguments in API calls:
- *
- * 1. Context pointers go first, followed by output arguments, combined
- * output/input arguments, and finally input-only arguments.
- * 2. Array lengths always immediately the follow the argument whose length
- * they describe, even if this violates rule 1.
- * 3. Within the OUT/OUTIN/IN groups, pointers to data that is typically generated
- * later go first. This means: signatures, public nonces, private nonces,
- * messages, public keys, secret keys, tweaks.
- * 4. Arguments that are not data pointers go last, from more complex to less
- * complex: function pointers, algorithm names, messages, void pointers,
- * counts, flags, booleans.
- * 5. Opaque data pointers follow the function pointer they are to be passed to.
- */
-
-/** Opaque data structure that holds context information (precomputed tables etc.).
- *
- * The purpose of context structures is to cache large precomputed data tables
- * that are expensive to construct, and also to maintain the randomization data
- * for blinding.
- *
- * Do not create a new context object for each operation, as construction is
- * far slower than all other API calls (~100 times slower than an ECDSA
- * verification).
- *
- * A constructed context can safely be used from multiple threads
- * simultaneously, but API call that take a non-const pointer to a context
- * need exclusive access to it. In particular this is the case for
- * secp256k1_context_destroy and secp256k1_context_randomize.
- *
- * Regarding randomization, either do it once at creation time (in which case
- * you do not need any locking for the other calls), or use a read-write lock.
- */
-typedef struct secp256k1_context_struct secp256k1_context;
-
-/** Opaque data structure that holds a parsed and valid public key.
- *
- * The exact representation of data inside is implementation defined and not
- * guaranteed to be portable between different platforms or versions. It is
- * however guaranteed to be 64 bytes in size, and can be safely copied/moved.
- * If you need to convert to a format suitable for storage, transmission, or
- * comparison, use secp256k1_ec_pubkey_serialize and secp256k1_ec_pubkey_parse.
- */
-typedef struct {
- unsigned char data[64];
-} secp256k1_pubkey;
-
-/** Opaque data structured that holds a parsed ECDSA signature.
- *
- * The exact representation of data inside is implementation defined and not
- * guaranteed to be portable between different platforms or versions. It is
- * however guaranteed to be 64 bytes in size, and can be safely copied/moved.
- * If you need to convert to a format suitable for storage, transmission, or
- * comparison, use the secp256k1_ecdsa_signature_serialize_* and
- * secp256k1_ecdsa_signature_serialize_* functions.
- */
-typedef struct {
- unsigned char data[64];
-} secp256k1_ecdsa_signature;
-
-/** A pointer to a function to deterministically generate a nonce.
- *
- * Returns: 1 if a nonce was successfully generated. 0 will cause signing to fail.
- * Out: nonce32: pointer to a 32-byte array to be filled by the function.
- * In: msg32: the 32-byte message hash being verified (will not be NULL)
- * key32: pointer to a 32-byte secret key (will not be NULL)
- * algo16: pointer to a 16-byte array describing the signature
- * algorithm (will be NULL for ECDSA for compatibility).
- * data: Arbitrary data pointer that is passed through.
- * attempt: how many iterations we have tried to find a nonce.
- * This will almost always be 0, but different attempt values
- * are required to result in a different nonce.
- *
- * Except for test cases, this function should compute some cryptographic hash of
- * the message, the algorithm, the key and the attempt.
- */
-typedef int (*secp256k1_nonce_function)(
- unsigned char *nonce32,
- const unsigned char *msg32,
- const unsigned char *key32,
- const unsigned char *algo16,
- void *data,
- unsigned int attempt
-);
-
-# if !defined(SECP256K1_GNUC_PREREQ)
-# if defined(__GNUC__)&&defined(__GNUC_MINOR__)
-# define SECP256K1_GNUC_PREREQ(_maj,_min) \
- ((__GNUC__<<16)+__GNUC_MINOR__>=((_maj)<<16)+(_min))
-# else
-# define SECP256K1_GNUC_PREREQ(_maj,_min) 0
-# endif
-# endif
-
-# if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) )
-# if SECP256K1_GNUC_PREREQ(2,7)
-# define SECP256K1_INLINE __inline__
-# elif (defined(_MSC_VER))
-# define SECP256K1_INLINE __inline
-# else
-# define SECP256K1_INLINE
-# endif
-# else
-# define SECP256K1_INLINE inline
-# endif
-
-#ifndef SECP256K1_API
-# if defined(_WIN32)
-# ifdef SECP256K1_BUILD
-# define SECP256K1_API __declspec(dllexport)
-# else
-# define SECP256K1_API
-# endif
-# elif defined(__GNUC__) && defined(SECP256K1_BUILD)
-# define SECP256K1_API __attribute__ ((visibility ("default")))
-# else
-# define SECP256K1_API
-# endif
-#endif
-
-/**Warning attributes
- * NONNULL is not used if SECP256K1_BUILD is set to avoid the compiler optimizing out
- * some paranoid null checks. */
-# if defined(__GNUC__) && SECP256K1_GNUC_PREREQ(3, 4)
-# define SECP256K1_WARN_UNUSED_RESULT __attribute__ ((__warn_unused_result__))
-# else
-# define SECP256K1_WARN_UNUSED_RESULT
-# endif
-# if !defined(SECP256K1_BUILD) && defined(__GNUC__) && SECP256K1_GNUC_PREREQ(3, 4)
-# define SECP256K1_ARG_NONNULL(_x) __attribute__ ((__nonnull__(_x)))
-# else
-# define SECP256K1_ARG_NONNULL(_x)
-# endif
-
-/** All flags' lower 8 bits indicate what they're for. Do not use directly. */
-#define SECP256K1_FLAGS_TYPE_MASK ((1 << 8) - 1)
-#define SECP256K1_FLAGS_TYPE_CONTEXT (1 << 0)
-#define SECP256K1_FLAGS_TYPE_COMPRESSION (1 << 1)
-/** The higher bits contain the actual data. Do not use directly. */
-#define SECP256K1_FLAGS_BIT_CONTEXT_VERIFY (1 << 8)
-#define SECP256K1_FLAGS_BIT_CONTEXT_SIGN (1 << 9)
-#define SECP256K1_FLAGS_BIT_COMPRESSION (1 << 8)
-
-/** Flags to pass to secp256k1_context_create. */
-#define SECP256K1_CONTEXT_VERIFY (SECP256K1_FLAGS_TYPE_CONTEXT | SECP256K1_FLAGS_BIT_CONTEXT_VERIFY)
-#define SECP256K1_CONTEXT_SIGN (SECP256K1_FLAGS_TYPE_CONTEXT | SECP256K1_FLAGS_BIT_CONTEXT_SIGN)
-#define SECP256K1_CONTEXT_NONE (SECP256K1_FLAGS_TYPE_CONTEXT)
-
-/** Flag to pass to secp256k1_ec_pubkey_serialize and secp256k1_ec_privkey_export. */
-#define SECP256K1_EC_COMPRESSED (SECP256K1_FLAGS_TYPE_COMPRESSION | SECP256K1_FLAGS_BIT_COMPRESSION)
-#define SECP256K1_EC_UNCOMPRESSED (SECP256K1_FLAGS_TYPE_COMPRESSION)
-
-/** Create a secp256k1 context object.
- *
- * Returns: a newly created context object.
- * In: flags: which parts of the context to initialize.
- */
-SECP256K1_API secp256k1_context* secp256k1_context_create(
- unsigned int flags
-) SECP256K1_WARN_UNUSED_RESULT;
-
-/** Copies a secp256k1 context object.
- *
- * Returns: a newly created context object.
- * Args: ctx: an existing context to copy (cannot be NULL)
- */
-SECP256K1_API secp256k1_context* secp256k1_context_clone(
- const secp256k1_context* ctx
-) SECP256K1_ARG_NONNULL(1) SECP256K1_WARN_UNUSED_RESULT;
-
-/** Destroy a secp256k1 context object.
- *
- * The context pointer may not be used afterwards.
- * Args: ctx: an existing context to destroy (cannot be NULL)
- */
-SECP256K1_API void secp256k1_context_destroy(
- secp256k1_context* ctx
-);
-
-/** Set a callback function to be called when an illegal argument is passed to
- * an API call. It will only trigger for violations that are mentioned
- * explicitly in the header.
- *
- * The philosophy is that these shouldn't be dealt with through a
- * specific return value, as calling code should not have branches to deal with
- * the case that this code itself is broken.
- *
- * On the other hand, during debug stage, one would want to be informed about
- * such mistakes, and the default (crashing) may be inadvisable.
- * When this callback is triggered, the API function called is guaranteed not
- * to cause a crash, though its return value and output arguments are
- * undefined.
- *
- * Args: ctx: an existing context object (cannot be NULL)
- * In: fun: a pointer to a function to call when an illegal argument is
- * passed to the API, taking a message and an opaque pointer
- * (NULL restores a default handler that calls abort).
- * data: the opaque pointer to pass to fun above.
- */
-SECP256K1_API void secp256k1_context_set_illegal_callback(
- secp256k1_context* ctx,
- void (*fun)(const char* message, void* data),
- const void* data
-) SECP256K1_ARG_NONNULL(1);
-
-/** Set a callback function to be called when an internal consistency check
- * fails. The default is crashing.
- *
- * This can only trigger in case of a hardware failure, miscompilation,
- * memory corruption, serious bug in the library, or other error would can
- * otherwise result in undefined behaviour. It will not trigger due to mere
- * incorrect usage of the API (see secp256k1_context_set_illegal_callback
- * for that). After this callback returns, anything may happen, including
- * crashing.
- *
- * Args: ctx: an existing context object (cannot be NULL)
- * In: fun: a pointer to a function to call when an internal error occurs,
- * taking a message and an opaque pointer (NULL restores a default
- * handler that calls abort).
- * data: the opaque pointer to pass to fun above.
- */
-SECP256K1_API void secp256k1_context_set_error_callback(
- secp256k1_context* ctx,
- void (*fun)(const char* message, void* data),
- const void* data
-) SECP256K1_ARG_NONNULL(1);
-
-/** Parse a variable-length public key into the pubkey object.
- *
- * Returns: 1 if the public key was fully valid.
- * 0 if the public key could not be parsed or is invalid.
- * Args: ctx: a secp256k1 context object.
- * Out: pubkey: pointer to a pubkey object. If 1 is returned, it is set to a
- * parsed version of input. If not, its value is undefined.
- * In: input: pointer to a serialized public key
- * inputlen: length of the array pointed to by input
- *
- * This function supports parsing compressed (33 bytes, header byte 0x02 or
- * 0x03), uncompressed (65 bytes, header byte 0x04), or hybrid (65 bytes, header
- * byte 0x06 or 0x07) format public keys.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_parse(
- const secp256k1_context* ctx,
- secp256k1_pubkey* pubkey,
- const unsigned char *input,
- size_t inputlen
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Serialize a pubkey object into a serialized byte sequence.
- *
- * Returns: 1 always.
- * Args: ctx: a secp256k1 context object.
- * Out: output: a pointer to a 65-byte (if compressed==0) or 33-byte (if
- * compressed==1) byte array to place the serialized key
- * in.
- * In/Out: outputlen: a pointer to an integer which is initially set to the
- * size of output, and is overwritten with the written
- * size.
- * In: pubkey: a pointer to a secp256k1_pubkey containing an
- * initialized public key.
- * flags: SECP256K1_EC_COMPRESSED if serialization should be in
- * compressed format, otherwise SECP256K1_EC_UNCOMPRESSED.
- */
-SECP256K1_API int secp256k1_ec_pubkey_serialize(
- const secp256k1_context* ctx,
- unsigned char *output,
- size_t *outputlen,
- const secp256k1_pubkey* pubkey,
- unsigned int flags
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Parse an ECDSA signature in compact (64 bytes) format.
- *
- * Returns: 1 when the signature could be parsed, 0 otherwise.
- * Args: ctx: a secp256k1 context object
- * Out: sig: a pointer to a signature object
- * In: input64: a pointer to the 64-byte array to parse
- *
- * The signature must consist of a 32-byte big endian R value, followed by a
- * 32-byte big endian S value. If R or S fall outside of [0..order-1], the
- * encoding is invalid. R and S with value 0 are allowed in the encoding.
- *
- * After the call, sig will always be initialized. If parsing failed or R or
- * S are zero, the resulting sig value is guaranteed to fail validation for any
- * message and public key.
- */
-SECP256K1_API int secp256k1_ecdsa_signature_parse_compact(
- const secp256k1_context* ctx,
- secp256k1_ecdsa_signature* sig,
- const unsigned char *input64
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Parse a DER ECDSA signature.
- *
- * Returns: 1 when the signature could be parsed, 0 otherwise.
- * Args: ctx: a secp256k1 context object
- * Out: sig: a pointer to a signature object
- * In: input: a pointer to the signature to be parsed
- * inputlen: the length of the array pointed to be input
- *
- * This function will accept any valid DER encoded signature, even if the
- * encoded numbers are out of range.
- *
- * After the call, sig will always be initialized. If parsing failed or the
- * encoded numbers are out of range, signature validation with it is
- * guaranteed to fail for every message and public key.
- */
-SECP256K1_API int secp256k1_ecdsa_signature_parse_der(
- const secp256k1_context* ctx,
- secp256k1_ecdsa_signature* sig,
- const unsigned char *input,
- size_t inputlen
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Serialize an ECDSA signature in DER format.
- *
- * Returns: 1 if enough space was available to serialize, 0 otherwise
- * Args: ctx: a secp256k1 context object
- * Out: output: a pointer to an array to store the DER serialization
- * In/Out: outputlen: a pointer to a length integer. Initially, this integer
- * should be set to the length of output. After the call
- * it will be set to the length of the serialization (even
- * if 0 was returned).
- * In: sig: a pointer to an initialized signature object
- */
-SECP256K1_API int secp256k1_ecdsa_signature_serialize_der(
- const secp256k1_context* ctx,
- unsigned char *output,
- size_t *outputlen,
- const secp256k1_ecdsa_signature* sig
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Serialize an ECDSA signature in compact (64 byte) format.
- *
- * Returns: 1
- * Args: ctx: a secp256k1 context object
- * Out: output64: a pointer to a 64-byte array to store the compact serialization
- * In: sig: a pointer to an initialized signature object
- *
- * See secp256k1_ecdsa_signature_parse_compact for details about the encoding.
- */
-SECP256K1_API int secp256k1_ecdsa_signature_serialize_compact(
- const secp256k1_context* ctx,
- unsigned char *output64,
- const secp256k1_ecdsa_signature* sig
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Verify an ECDSA signature.
- *
- * Returns: 1: correct signature
- * 0: incorrect or unparseable signature
- * Args: ctx: a secp256k1 context object, initialized for verification.
- * In: sig: the signature being verified (cannot be NULL)
- * msg32: the 32-byte message hash being verified (cannot be NULL)
- * pubkey: pointer to an initialized public key to verify with (cannot be NULL)
- *
- * To avoid accepting malleable signatures, only ECDSA signatures in lower-S
- * form are accepted.
- *
- * If you need to accept ECDSA signatures from sources that do not obey this
- * rule, apply secp256k1_ecdsa_signature_normalize to the signature prior to
- * validation, but be aware that doing so results in malleable signatures.
- *
- * For details, see the comments for that function.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdsa_verify(
- const secp256k1_context* ctx,
- const secp256k1_ecdsa_signature *sig,
- const unsigned char *msg32,
- const secp256k1_pubkey *pubkey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Convert a signature to a normalized lower-S form.
- *
- * Returns: 1 if sigin was not normalized, 0 if it already was.
- * Args: ctx: a secp256k1 context object
- * Out: sigout: a pointer to a signature to fill with the normalized form,
- * or copy if the input was already normalized. (can be NULL if
- * you're only interested in whether the input was already
- * normalized).
- * In: sigin: a pointer to a signature to check/normalize (cannot be NULL,
- * can be identical to sigout)
- *
- * With ECDSA a third-party can forge a second distinct signature of the same
- * message, given a single initial signature, but without knowing the key. This
- * is done by negating the S value modulo the order of the curve, 'flipping'
- * the sign of the random point R which is not included in the signature.
- *
- * Forgery of the same message isn't universally problematic, but in systems
- * where message malleability or uniqueness of signatures is important this can
- * cause issues. This forgery can be blocked by all verifiers forcing signers
- * to use a normalized form.
- *
- * The lower-S form reduces the size of signatures slightly on average when
- * variable length encodings (such as DER) are used and is cheap to verify,
- * making it a good choice. Security of always using lower-S is assured because
- * anyone can trivially modify a signature after the fact to enforce this
- * property anyway.
- *
- * The lower S value is always between 0x1 and
- * 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
- * inclusive.
- *
- * No other forms of ECDSA malleability are known and none seem likely, but
- * there is no formal proof that ECDSA, even with this additional restriction,
- * is free of other malleability. Commonly used serialization schemes will also
- * accept various non-unique encodings, so care should be taken when this
- * property is required for an application.
- *
- * The secp256k1_ecdsa_sign function will by default create signatures in the
- * lower-S form, and secp256k1_ecdsa_verify will not accept others. In case
- * signatures come from a system that cannot enforce this property,
- * secp256k1_ecdsa_signature_normalize must be called before verification.
- */
-SECP256K1_API int secp256k1_ecdsa_signature_normalize(
- const secp256k1_context* ctx,
- secp256k1_ecdsa_signature *sigout,
- const secp256k1_ecdsa_signature *sigin
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(3);
-
-/** An implementation of RFC6979 (using HMAC-SHA256) as nonce generation function.
- * If a data pointer is passed, it is assumed to be a pointer to 32 bytes of
- * extra entropy.
- */
-SECP256K1_API extern const secp256k1_nonce_function secp256k1_nonce_function_rfc6979;
-
-/** A default safe nonce generation function (currently equal to secp256k1_nonce_function_rfc6979). */
-SECP256K1_API extern const secp256k1_nonce_function secp256k1_nonce_function_default;
-
-/** Create an ECDSA signature.
- *
- * Returns: 1: signature created
- * 0: the nonce generation function failed, or the private key was invalid.
- * Args: ctx: pointer to a context object, initialized for signing (cannot be NULL)
- * Out: sig: pointer to an array where the signature will be placed (cannot be NULL)
- * In: msg32: the 32-byte message hash being signed (cannot be NULL)
- * seckey: pointer to a 32-byte secret key (cannot be NULL)
- * noncefp:pointer to a nonce generation function. If NULL, secp256k1_nonce_function_default is used
- * ndata: pointer to arbitrary data used by the nonce generation function (can be NULL)
- *
- * The created signature is always in lower-S form. See
- * secp256k1_ecdsa_signature_normalize for more details.
- */
-SECP256K1_API int secp256k1_ecdsa_sign(
- const secp256k1_context* ctx,
- secp256k1_ecdsa_signature *sig,
- const unsigned char *msg32,
- const unsigned char *seckey,
- secp256k1_nonce_function noncefp,
- const void *ndata
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Verify an ECDSA secret key.
- *
- * Returns: 1: secret key is valid
- * 0: secret key is invalid
- * Args: ctx: pointer to a context object (cannot be NULL)
- * In: seckey: pointer to a 32-byte secret key (cannot be NULL)
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_seckey_verify(
- const secp256k1_context* ctx,
- const unsigned char *seckey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2);
-
-/** Compute the public key for a secret key.
- *
- * Returns: 1: secret was valid, public key stores
- * 0: secret was invalid, try again
- * Args: ctx: pointer to a context object, initialized for signing (cannot be NULL)
- * Out: pubkey: pointer to the created public key (cannot be NULL)
- * In: seckey: pointer to a 32-byte private key (cannot be NULL)
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_create(
- const secp256k1_context* ctx,
- secp256k1_pubkey *pubkey,
- const unsigned char *seckey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Tweak a private key by adding tweak to it.
- * Returns: 0 if the tweak was out of range (chance of around 1 in 2^128 for
- * uniformly random 32-byte arrays, or if the resulting private key
- * would be invalid (only when the tweak is the complement of the
- * private key). 1 otherwise.
- * Args: ctx: pointer to a context object (cannot be NULL).
- * In/Out: seckey: pointer to a 32-byte private key.
- * In: tweak: pointer to a 32-byte tweak.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_tweak_add(
- const secp256k1_context* ctx,
- unsigned char *seckey,
- const unsigned char *tweak
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Tweak a public key by adding tweak times the generator to it.
- * Returns: 0 if the tweak was out of range (chance of around 1 in 2^128 for
- * uniformly random 32-byte arrays, or if the resulting public key
- * would be invalid (only when the tweak is the complement of the
- * corresponding private key). 1 otherwise.
- * Args: ctx: pointer to a context object initialized for validation
- * (cannot be NULL).
- * In/Out: pubkey: pointer to a public key object.
- * In: tweak: pointer to a 32-byte tweak.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_tweak_add(
- const secp256k1_context* ctx,
- secp256k1_pubkey *pubkey,
- const unsigned char *tweak
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Tweak a private key by multiplying it by a tweak.
- * Returns: 0 if the tweak was out of range (chance of around 1 in 2^128 for
- * uniformly random 32-byte arrays, or equal to zero. 1 otherwise.
- * Args: ctx: pointer to a context object (cannot be NULL).
- * In/Out: seckey: pointer to a 32-byte private key.
- * In: tweak: pointer to a 32-byte tweak.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_privkey_tweak_mul(
- const secp256k1_context* ctx,
- unsigned char *seckey,
- const unsigned char *tweak
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Tweak a public key by multiplying it by a tweak value.
- * Returns: 0 if the tweak was out of range (chance of around 1 in 2^128 for
- * uniformly random 32-byte arrays, or equal to zero. 1 otherwise.
- * Args: ctx: pointer to a context object initialized for validation
- * (cannot be NULL).
- * In/Out: pubkey: pointer to a public key obkect.
- * In: tweak: pointer to a 32-byte tweak.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_tweak_mul(
- const secp256k1_context* ctx,
- secp256k1_pubkey *pubkey,
- const unsigned char *tweak
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Updates the context randomization.
- * Returns: 1: randomization successfully updated
- * 0: error
- * Args: ctx: pointer to a context object (cannot be NULL)
- * In: seed32: pointer to a 32-byte random seed (NULL resets to initial state)
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_context_randomize(
- secp256k1_context* ctx,
- const unsigned char *seed32
-) SECP256K1_ARG_NONNULL(1);
-
-/** Add a number of public keys together.
- * Returns: 1: the sum of the public keys is valid.
- * 0: the sum of the public keys is not valid.
- * Args: ctx: pointer to a context object
- * Out: out: pointer to a public key object for placing the resulting public key
- * (cannot be NULL)
- * In: ins: pointer to array of pointers to public keys (cannot be NULL)
- * n: the number of public keys to add together (must be at least 1)
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_pubkey_combine(
- const secp256k1_context* ctx,
- secp256k1_pubkey *out,
- const secp256k1_pubkey * const * ins,
- size_t n
-) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-# ifdef __cplusplus
-}
-# endif
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/include/secp256k1_ecdh.h op-geth/crypto/secp256k1/libsecp256k1/include/secp256k1_ecdh.h
deleted file mode 100644
index 4b84d7a963499698ff6c8b920d337fed2d1cb5f7..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/include/secp256k1_ecdh.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef _SECP256K1_ECDH_
-# define _SECP256K1_ECDH_
-
-# include "secp256k1.h"
-
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-/** Compute an EC Diffie-Hellman secret in constant time
- * Returns: 1: exponentiation was successful
- * 0: scalar was invalid (zero or overflow)
- * Args: ctx: pointer to a context object (cannot be NULL)
- * Out: result: a 32-byte array which will be populated by an ECDH
- * secret computed from the point and scalar
- * In: pubkey: a pointer to a secp256k1_pubkey containing an
- * initialized public key
- * privkey: a 32-byte scalar with which to multiply the point
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdh(
- const secp256k1_context* ctx,
- unsigned char *result,
- const secp256k1_pubkey *pubkey,
- const unsigned char *privkey
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-# ifdef __cplusplus
-}
-# endif
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/include/secp256k1_recovery.h op-geth/crypto/secp256k1/libsecp256k1/include/secp256k1_recovery.h
deleted file mode 100644
index 05537972532fb89feb6693d07c19168688136f38..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/include/secp256k1_recovery.h
+++ /dev/null
@@ -1,110 +0,0 @@
-#ifndef _SECP256K1_RECOVERY_
-# define _SECP256K1_RECOVERY_
-
-# include "secp256k1.h"
-
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-/** Opaque data structured that holds a parsed ECDSA signature,
- * supporting pubkey recovery.
- *
- * The exact representation of data inside is implementation defined and not
- * guaranteed to be portable between different platforms or versions. It is
- * however guaranteed to be 65 bytes in size, and can be safely copied/moved.
- * If you need to convert to a format suitable for storage or transmission, use
- * the secp256k1_ecdsa_signature_serialize_* and
- * secp256k1_ecdsa_signature_parse_* functions.
- *
- * Furthermore, it is guaranteed that identical signatures (including their
- * recoverability) will have identical representation, so they can be
- * memcmp'ed.
- */
-typedef struct {
- unsigned char data[65];
-} secp256k1_ecdsa_recoverable_signature;
-
-/** Parse a compact ECDSA signature (64 bytes + recovery id).
- *
- * Returns: 1 when the signature could be parsed, 0 otherwise
- * Args: ctx: a secp256k1 context object
- * Out: sig: a pointer to a signature object
- * In: input64: a pointer to a 64-byte compact signature
- * recid: the recovery id (0, 1, 2 or 3)
- */
-SECP256K1_API int secp256k1_ecdsa_recoverable_signature_parse_compact(
- const secp256k1_context* ctx,
- secp256k1_ecdsa_recoverable_signature* sig,
- const unsigned char *input64,
- int recid
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Convert a recoverable signature into a normal signature.
- *
- * Returns: 1
- * Out: sig: a pointer to a normal signature (cannot be NULL).
- * In: sigin: a pointer to a recoverable signature (cannot be NULL).
- */
-SECP256K1_API int secp256k1_ecdsa_recoverable_signature_convert(
- const secp256k1_context* ctx,
- secp256k1_ecdsa_signature* sig,
- const secp256k1_ecdsa_recoverable_signature* sigin
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
-
-/** Serialize an ECDSA signature in compact format (64 bytes + recovery id).
- *
- * Returns: 1
- * Args: ctx: a secp256k1 context object
- * Out: output64: a pointer to a 64-byte array of the compact signature (cannot be NULL)
- * recid: a pointer to an integer to hold the recovery id (can be NULL).
- * In: sig: a pointer to an initialized signature object (cannot be NULL)
- */
-SECP256K1_API int secp256k1_ecdsa_recoverable_signature_serialize_compact(
- const secp256k1_context* ctx,
- unsigned char *output64,
- int *recid,
- const secp256k1_ecdsa_recoverable_signature* sig
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Create a recoverable ECDSA signature.
- *
- * Returns: 1: signature created
- * 0: the nonce generation function failed, or the private key was invalid.
- * Args: ctx: pointer to a context object, initialized for signing (cannot be NULL)
- * Out: sig: pointer to an array where the signature will be placed (cannot be NULL)
- * In: msg32: the 32-byte message hash being signed (cannot be NULL)
- * seckey: pointer to a 32-byte secret key (cannot be NULL)
- * noncefp:pointer to a nonce generation function. If NULL, secp256k1_nonce_function_default is used
- * ndata: pointer to arbitrary data used by the nonce generation function (can be NULL)
- */
-SECP256K1_API int secp256k1_ecdsa_sign_recoverable(
- const secp256k1_context* ctx,
- secp256k1_ecdsa_recoverable_signature *sig,
- const unsigned char *msg32,
- const unsigned char *seckey,
- secp256k1_nonce_function noncefp,
- const void *ndata
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-/** Recover an ECDSA public key from a signature.
- *
- * Returns: 1: public key successfully recovered (which guarantees a correct signature).
- * 0: otherwise.
- * Args: ctx: pointer to a context object, initialized for verification (cannot be NULL)
- * Out: pubkey: pointer to the recovered public key (cannot be NULL)
- * In: sig: pointer to initialized signature that supports pubkey recovery (cannot be NULL)
- * msg32: the 32-byte message hash assumed to be signed (cannot be NULL)
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdsa_recover(
- const secp256k1_context* ctx,
- secp256k1_pubkey *pubkey,
- const secp256k1_ecdsa_recoverable_signature *sig,
- const unsigned char *msg32
-) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
-
-# ifdef __cplusplus
-}
-# endif
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/libsecp256k1.pc.in op-geth/crypto/secp256k1/libsecp256k1/libsecp256k1.pc.in
deleted file mode 100644
index a0d006f1131f47d9bb80de6d425e38912e1258f0..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/libsecp256k1.pc.in
+++ /dev/null
@@ -1,13 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-Name: libsecp256k1
-Description: Optimized C library for EC operations on curve secp256k1
-URL: https://github.com/bitcoin-core/secp256k1
-Version: @PACKAGE_VERSION@
-Cflags: -I${includedir}
-Libs.private: @SECP_LIBS@
-Libs: -L${libdir} -lsecp256k1
-
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/obj/.gitignore op-geth/crypto/secp256k1/libsecp256k1/obj/.gitignore
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
Binary files go-ethereum/crypto/secp256k1/libsecp256k1/obj/.gitignore and /dev/null differ
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/sage/group_prover.sage op-geth/crypto/secp256k1/libsecp256k1/sage/group_prover.sage
deleted file mode 100644
index ab580c5b23bbf786f41757b8a3800958db37c7a7..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/sage/group_prover.sage
+++ /dev/null
@@ -1,322 +0,0 @@
-# This code supports verifying group implementations which have branches
-# or conditional statements (like cmovs), by allowing each execution path
-# to independently set assumptions on input or intermediary variables.
-#
-# The general approach is:
-# * A constraint is a tuple of two sets of of symbolic expressions:
-# the first of which are required to evaluate to zero, the second of which
-# are required to evaluate to nonzero.
-# - A constraint is said to be conflicting if any of its nonzero expressions
-# is in the ideal with basis the zero expressions (in other words: when the
-# zero expressions imply that one of the nonzero expressions are zero).
-# * There is a list of laws that describe the intended behaviour, including
-# laws for addition and doubling. Each law is called with the symbolic point
-# coordinates as arguments, and returns:
-# - A constraint describing the assumptions under which it is applicable,
-# called "assumeLaw"
-# - A constraint describing the requirements of the law, called "require"
-# * Implementations are transliterated into functions that operate as well on
-# algebraic input points, and are called once per combination of branches
-# exectured. Each execution returns:
-# - A constraint describing the assumptions this implementation requires
-# (such as Z1=1), called "assumeFormula"
-# - A constraint describing the assumptions this specific branch requires,
-# but which is by construction guaranteed to cover the entire space by
-# merging the results from all branches, called "assumeBranch"
-# - The result of the computation
-# * All combinations of laws with implementation branches are tried, and:
-# - If the combination of assumeLaw, assumeFormula, and assumeBranch results
-# in a conflict, it means this law does not apply to this branch, and it is
-# skipped.
-# - For others, we try to prove the require constraints hold, assuming the
-# information in assumeLaw + assumeFormula + assumeBranch, and if this does
-# not succeed, we fail.
-# + To prove an expression is zero, we check whether it belongs to the
-# ideal with the assumed zero expressions as basis. This test is exact.
-# + To prove an expression is nonzero, we check whether each of its
-# factors is contained in the set of nonzero assumptions' factors.
-# This test is not exact, so various combinations of original and
-# reduced expressions' factors are tried.
-# - If we succeed, we print out the assumptions from assumeFormula that
-# weren't implied by assumeLaw already. Those from assumeBranch are skipped,
-# as we assume that all constraints in it are complementary with each other.
-#
-# Based on the sage verification scripts used in the Explicit-Formulas Database
-# by Tanja Lange and others, see http://hyperelliptic.org/EFD
-
-class fastfrac:
- """Fractions over rings."""
-
- def __init__(self,R,top,bot=1):
- """Construct a fractional, given a ring, a numerator, and denominator."""
- self.R = R
- if parent(top) == ZZ or parent(top) == R:
- self.top = R(top)
- self.bot = R(bot)
- elif top.__class__ == fastfrac:
- self.top = top.top
- self.bot = top.bot * bot
- else:
- self.top = R(numerator(top))
- self.bot = R(denominator(top)) * bot
-
- def iszero(self,I):
- """Return whether this fraction is zero given an ideal."""
- return self.top in I and self.bot not in I
-
- def reduce(self,assumeZero):
- zero = self.R.ideal(map(numerator, assumeZero))
- return fastfrac(self.R, zero.reduce(self.top)) / fastfrac(self.R, zero.reduce(self.bot))
-
- def __add__(self,other):
- """Add two fractions."""
- if parent(other) == ZZ:
- return fastfrac(self.R,self.top + self.bot * other,self.bot)
- if other.__class__ == fastfrac:
- return fastfrac(self.R,self.top * other.bot + self.bot * other.top,self.bot * other.bot)
- return NotImplemented
-
- def __sub__(self,other):
- """Subtract two fractions."""
- if parent(other) == ZZ:
- return fastfrac(self.R,self.top - self.bot * other,self.bot)
- if other.__class__ == fastfrac:
- return fastfrac(self.R,self.top * other.bot - self.bot * other.top,self.bot * other.bot)
- return NotImplemented
-
- def __neg__(self):
- """Return the negation of a fraction."""
- return fastfrac(self.R,-self.top,self.bot)
-
- def __mul__(self,other):
- """Multiply two fractions."""
- if parent(other) == ZZ:
- return fastfrac(self.R,self.top * other,self.bot)
- if other.__class__ == fastfrac:
- return fastfrac(self.R,self.top * other.top,self.bot * other.bot)
- return NotImplemented
-
- def __rmul__(self,other):
- """Multiply something else with a fraction."""
- return self.__mul__(other)
-
- def __div__(self,other):
- """Divide two fractions."""
- if parent(other) == ZZ:
- return fastfrac(self.R,self.top,self.bot * other)
- if other.__class__ == fastfrac:
- return fastfrac(self.R,self.top * other.bot,self.bot * other.top)
- return NotImplemented
-
- def __pow__(self,other):
- """Compute a power of a fraction."""
- if parent(other) == ZZ:
- if other < 0:
- # Negative powers require flipping top and bottom
- return fastfrac(self.R,self.bot ^ (-other),self.top ^ (-other))
- else:
- return fastfrac(self.R,self.top ^ other,self.bot ^ other)
- return NotImplemented
-
- def __str__(self):
- return "fastfrac((" + str(self.top) + ") / (" + str(self.bot) + "))"
- def __repr__(self):
- return "%s" % self
-
- def numerator(self):
- return self.top
-
-class constraints:
- """A set of constraints, consisting of zero and nonzero expressions.
-
- Constraints can either be used to express knowledge or a requirement.
-
- Both the fields zero and nonzero are maps from expressions to description
- strings. The expressions that are the keys in zero are required to be zero,
- and the expressions that are the keys in nonzero are required to be nonzero.
-
- Note that (a != 0) and (b != 0) is the same as (a*b != 0), so all keys in
- nonzero could be multiplied into a single key. This is often much less
- efficient to work with though, so we keep them separate inside the
- constraints. This allows higher-level code to do fast checks on the individual
- nonzero elements, or combine them if needed for stronger checks.
-
- We can't multiply the different zero elements, as it would suffice for one of
- the factors to be zero, instead of all of them. Instead, the zero elements are
- typically combined into an ideal first.
- """
-
- def __init__(self, **kwargs):
- if 'zero' in kwargs:
- self.zero = dict(kwargs['zero'])
- else:
- self.zero = dict()
- if 'nonzero' in kwargs:
- self.nonzero = dict(kwargs['nonzero'])
- else:
- self.nonzero = dict()
-
- def negate(self):
- return constraints(zero=self.nonzero, nonzero=self.zero)
-
- def __add__(self, other):
- zero = self.zero.copy()
- zero.update(other.zero)
- nonzero = self.nonzero.copy()
- nonzero.update(other.nonzero)
- return constraints(zero=zero, nonzero=nonzero)
-
- def __str__(self):
- return "constraints(zero=%s,nonzero=%s)" % (self.zero, self.nonzero)
-
- def __repr__(self):
- return "%s" % self
-
-
-def conflicts(R, con):
- """Check whether any of the passed non-zero assumptions is implied by the zero assumptions"""
- zero = R.ideal(map(numerator, con.zero))
- if 1 in zero:
- return True
- # First a cheap check whether any of the individual nonzero terms conflict on
- # their own.
- for nonzero in con.nonzero:
- if nonzero.iszero(zero):
- return True
- # It can be the case that entries in the nonzero set do not individually
- # conflict with the zero set, but their combination does. For example, knowing
- # that either x or y is zero is equivalent to having x*y in the zero set.
- # Having x or y individually in the nonzero set is not a conflict, but both
- # simultaneously is, so that is the right thing to check for.
- if reduce(lambda a,b: a * b, con.nonzero, fastfrac(R, 1)).iszero(zero):
- return True
- return False
-
-
-def get_nonzero_set(R, assume):
- """Calculate a simple set of nonzero expressions"""
- zero = R.ideal(map(numerator, assume.zero))
- nonzero = set()
- for nz in map(numerator, assume.nonzero):
- for (f,n) in nz.factor():
- nonzero.add(f)
- rnz = zero.reduce(nz)
- for (f,n) in rnz.factor():
- nonzero.add(f)
- return nonzero
-
-
-def prove_nonzero(R, exprs, assume):
- """Check whether an expression is provably nonzero, given assumptions"""
- zero = R.ideal(map(numerator, assume.zero))
- nonzero = get_nonzero_set(R, assume)
- expl = set()
- ok = True
- for expr in exprs:
- if numerator(expr) in zero:
- return (False, [exprs[expr]])
- allexprs = reduce(lambda a,b: numerator(a)*numerator(b), exprs, 1)
- for (f, n) in allexprs.factor():
- if f not in nonzero:
- ok = False
- if ok:
- return (True, None)
- ok = True
- for (f, n) in zero.reduce(numerator(allexprs)).factor():
- if f not in nonzero:
- ok = False
- if ok:
- return (True, None)
- ok = True
- for expr in exprs:
- for (f,n) in numerator(expr).factor():
- if f not in nonzero:
- ok = False
- if ok:
- return (True, None)
- ok = True
- for expr in exprs:
- for (f,n) in zero.reduce(numerator(expr)).factor():
- if f not in nonzero:
- expl.add(exprs[expr])
- if expl:
- return (False, list(expl))
- else:
- return (True, None)
-
-
-def prove_zero(R, exprs, assume):
- """Check whether all of the passed expressions are provably zero, given assumptions"""
- r, e = prove_nonzero(R, dict(map(lambda x: (fastfrac(R, x.bot, 1), exprs[x]), exprs)), assume)
- if not r:
- return (False, map(lambda x: "Possibly zero denominator: %s" % x, e))
- zero = R.ideal(map(numerator, assume.zero))
- nonzero = prod(x for x in assume.nonzero)
- expl = []
- for expr in exprs:
- if not expr.iszero(zero):
- expl.append(exprs[expr])
- if not expl:
- return (True, None)
- return (False, expl)
-
-
-def describe_extra(R, assume, assumeExtra):
- """Describe what assumptions are added, given existing assumptions"""
- zerox = assume.zero.copy()
- zerox.update(assumeExtra.zero)
- zero = R.ideal(map(numerator, assume.zero))
- zeroextra = R.ideal(map(numerator, zerox))
- nonzero = get_nonzero_set(R, assume)
- ret = set()
- # Iterate over the extra zero expressions
- for base in assumeExtra.zero:
- if base not in zero:
- add = []
- for (f, n) in numerator(base).factor():
- if f not in nonzero:
- add += ["%s" % f]
- if add:
- ret.add((" * ".join(add)) + " = 0 [%s]" % assumeExtra.zero[base])
- # Iterate over the extra nonzero expressions
- for nz in assumeExtra.nonzero:
- nzr = zeroextra.reduce(numerator(nz))
- if nzr not in zeroextra:
- for (f,n) in nzr.factor():
- if zeroextra.reduce(f) not in nonzero:
- ret.add("%s != 0" % zeroextra.reduce(f))
- return ", ".join(x for x in ret)
-
-
-def check_symbolic(R, assumeLaw, assumeAssert, assumeBranch, require):
- """Check a set of zero and nonzero requirements, given a set of zero and nonzero assumptions"""
- assume = assumeLaw + assumeAssert + assumeBranch
-
- if conflicts(R, assume):
- # This formula does not apply
- return None
-
- describe = describe_extra(R, assumeLaw + assumeBranch, assumeAssert)
-
- ok, msg = prove_zero(R, require.zero, assume)
- if not ok:
- return "FAIL, %s fails (assuming %s)" % (str(msg), describe)
-
- res, expl = prove_nonzero(R, require.nonzero, assume)
- if not res:
- return "FAIL, %s fails (assuming %s)" % (str(expl), describe)
-
- if describe != "":
- return "OK (assuming %s)" % describe
- else:
- return "OK"
-
-
-def concrete_verify(c):
- for k in c.zero:
- if k != 0:
- return (False, c.zero[k])
- for k in c.nonzero:
- if k == 0:
- return (False, c.nonzero[k])
- return (True, None)
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/sage/secp256k1.sage op-geth/crypto/secp256k1/libsecp256k1/sage/secp256k1.sage
deleted file mode 100644
index a97e732f7fa3ab681a63070eda20455cda3a6c32..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/sage/secp256k1.sage
+++ /dev/null
@@ -1,306 +0,0 @@
-# Test libsecp256k1' group operation implementations using prover.sage
-
-import sys
-
-load("group_prover.sage")
-load("weierstrass_prover.sage")
-
-def formula_secp256k1_gej_double_var(a):
- """libsecp256k1's secp256k1_gej_double_var, used by various addition functions"""
- rz = a.Z * a.Y
- rz = rz * 2
- t1 = a.X^2
- t1 = t1 * 3
- t2 = t1^2
- t3 = a.Y^2
- t3 = t3 * 2
- t4 = t3^2
- t4 = t4 * 2
- t3 = t3 * a.X
- rx = t3
- rx = rx * 4
- rx = -rx
- rx = rx + t2
- t2 = -t2
- t3 = t3 * 6
- t3 = t3 + t2
- ry = t1 * t3
- t2 = -t4
- ry = ry + t2
- return jacobianpoint(rx, ry, rz)
-
-def formula_secp256k1_gej_add_var(branch, a, b):
- """libsecp256k1's secp256k1_gej_add_var"""
- if branch == 0:
- return (constraints(), constraints(nonzero={a.Infinity : 'a_infinite'}), b)
- if branch == 1:
- return (constraints(), constraints(zero={a.Infinity : 'a_finite'}, nonzero={b.Infinity : 'b_infinite'}), a)
- z22 = b.Z^2
- z12 = a.Z^2
- u1 = a.X * z22
- u2 = b.X * z12
- s1 = a.Y * z22
- s1 = s1 * b.Z
- s2 = b.Y * z12
- s2 = s2 * a.Z
- h = -u1
- h = h + u2
- i = -s1
- i = i + s2
- if branch == 2:
- r = formula_secp256k1_gej_double_var(a)
- return (constraints(), constraints(zero={h : 'h=0', i : 'i=0', a.Infinity : 'a_finite', b.Infinity : 'b_finite'}), r)
- if branch == 3:
- return (constraints(), constraints(zero={h : 'h=0', a.Infinity : 'a_finite', b.Infinity : 'b_finite'}, nonzero={i : 'i!=0'}), point_at_infinity())
- i2 = i^2
- h2 = h^2
- h3 = h2 * h
- h = h * b.Z
- rz = a.Z * h
- t = u1 * h2
- rx = t
- rx = rx * 2
- rx = rx + h3
- rx = -rx
- rx = rx + i2
- ry = -rx
- ry = ry + t
- ry = ry * i
- h3 = h3 * s1
- h3 = -h3
- ry = ry + h3
- return (constraints(), constraints(zero={a.Infinity : 'a_finite', b.Infinity : 'b_finite'}, nonzero={h : 'h!=0'}), jacobianpoint(rx, ry, rz))
-
-def formula_secp256k1_gej_add_ge_var(branch, a, b):
- """libsecp256k1's secp256k1_gej_add_ge_var, which assume bz==1"""
- if branch == 0:
- return (constraints(zero={b.Z - 1 : 'b.z=1'}), constraints(nonzero={a.Infinity : 'a_infinite'}), b)
- if branch == 1:
- return (constraints(zero={b.Z - 1 : 'b.z=1'}), constraints(zero={a.Infinity : 'a_finite'}, nonzero={b.Infinity : 'b_infinite'}), a)
- z12 = a.Z^2
- u1 = a.X
- u2 = b.X * z12
- s1 = a.Y
- s2 = b.Y * z12
- s2 = s2 * a.Z
- h = -u1
- h = h + u2
- i = -s1
- i = i + s2
- if (branch == 2):
- r = formula_secp256k1_gej_double_var(a)
- return (constraints(zero={b.Z - 1 : 'b.z=1'}), constraints(zero={a.Infinity : 'a_finite', b.Infinity : 'b_finite', h : 'h=0', i : 'i=0'}), r)
- if (branch == 3):
- return (constraints(zero={b.Z - 1 : 'b.z=1'}), constraints(zero={a.Infinity : 'a_finite', b.Infinity : 'b_finite', h : 'h=0'}, nonzero={i : 'i!=0'}), point_at_infinity())
- i2 = i^2
- h2 = h^2
- h3 = h * h2
- rz = a.Z * h
- t = u1 * h2
- rx = t
- rx = rx * 2
- rx = rx + h3
- rx = -rx
- rx = rx + i2
- ry = -rx
- ry = ry + t
- ry = ry * i
- h3 = h3 * s1
- h3 = -h3
- ry = ry + h3
- return (constraints(zero={b.Z - 1 : 'b.z=1'}), constraints(zero={a.Infinity : 'a_finite', b.Infinity : 'b_finite'}, nonzero={h : 'h!=0'}), jacobianpoint(rx, ry, rz))
-
-def formula_secp256k1_gej_add_zinv_var(branch, a, b):
- """libsecp256k1's secp256k1_gej_add_zinv_var"""
- bzinv = b.Z^(-1)
- if branch == 0:
- return (constraints(), constraints(nonzero={b.Infinity : 'b_infinite'}), a)
- if branch == 1:
- bzinv2 = bzinv^2
- bzinv3 = bzinv2 * bzinv
- rx = b.X * bzinv2
- ry = b.Y * bzinv3
- rz = 1
- return (constraints(), constraints(zero={b.Infinity : 'b_finite'}, nonzero={a.Infinity : 'a_infinite'}), jacobianpoint(rx, ry, rz))
- azz = a.Z * bzinv
- z12 = azz^2
- u1 = a.X
- u2 = b.X * z12
- s1 = a.Y
- s2 = b.Y * z12
- s2 = s2 * azz
- h = -u1
- h = h + u2
- i = -s1
- i = i + s2
- if branch == 2:
- r = formula_secp256k1_gej_double_var(a)
- return (constraints(), constraints(zero={a.Infinity : 'a_finite', b.Infinity : 'b_finite', h : 'h=0', i : 'i=0'}), r)
- if branch == 3:
- return (constraints(), constraints(zero={a.Infinity : 'a_finite', b.Infinity : 'b_finite', h : 'h=0'}, nonzero={i : 'i!=0'}), point_at_infinity())
- i2 = i^2
- h2 = h^2
- h3 = h * h2
- rz = a.Z
- rz = rz * h
- t = u1 * h2
- rx = t
- rx = rx * 2
- rx = rx + h3
- rx = -rx
- rx = rx + i2
- ry = -rx
- ry = ry + t
- ry = ry * i
- h3 = h3 * s1
- h3 = -h3
- ry = ry + h3
- return (constraints(), constraints(zero={a.Infinity : 'a_finite', b.Infinity : 'b_finite'}, nonzero={h : 'h!=0'}), jacobianpoint(rx, ry, rz))
-
-def formula_secp256k1_gej_add_ge(branch, a, b):
- """libsecp256k1's secp256k1_gej_add_ge"""
- zeroes = {}
- nonzeroes = {}
- a_infinity = False
- if (branch & 4) != 0:
- nonzeroes.update({a.Infinity : 'a_infinite'})
- a_infinity = True
- else:
- zeroes.update({a.Infinity : 'a_finite'})
- zz = a.Z^2
- u1 = a.X
- u2 = b.X * zz
- s1 = a.Y
- s2 = b.Y * zz
- s2 = s2 * a.Z
- t = u1
- t = t + u2
- m = s1
- m = m + s2
- rr = t^2
- m_alt = -u2
- tt = u1 * m_alt
- rr = rr + tt
- degenerate = (branch & 3) == 3
- if (branch & 1) != 0:
- zeroes.update({m : 'm_zero'})
- else:
- nonzeroes.update({m : 'm_nonzero'})
- if (branch & 2) != 0:
- zeroes.update({rr : 'rr_zero'})
- else:
- nonzeroes.update({rr : 'rr_nonzero'})
- rr_alt = s1
- rr_alt = rr_alt * 2
- m_alt = m_alt + u1
- if not degenerate:
- rr_alt = rr
- m_alt = m
- n = m_alt^2
- q = n * t
- n = n^2
- if degenerate:
- n = m
- t = rr_alt^2
- rz = a.Z * m_alt
- infinity = False
- if (branch & 8) != 0:
- if not a_infinity:
- infinity = True
- zeroes.update({rz : 'r.z=0'})
- else:
- nonzeroes.update({rz : 'r.z!=0'})
- rz = rz * 2
- q = -q
- t = t + q
- rx = t
- t = t * 2
- t = t + q
- t = t * rr_alt
- t = t + n
- ry = -t
- rx = rx * 4
- ry = ry * 4
- if a_infinity:
- rx = b.X
- ry = b.Y
- rz = 1
- if infinity:
- return (constraints(zero={b.Z - 1 : 'b.z=1', b.Infinity : 'b_finite'}), constraints(zero=zeroes, nonzero=nonzeroes), point_at_infinity())
- return (constraints(zero={b.Z - 1 : 'b.z=1', b.Infinity : 'b_finite'}), constraints(zero=zeroes, nonzero=nonzeroes), jacobianpoint(rx, ry, rz))
-
-def formula_secp256k1_gej_add_ge_old(branch, a, b):
- """libsecp256k1's old secp256k1_gej_add_ge, which fails when ay+by=0 but ax!=bx"""
- a_infinity = (branch & 1) != 0
- zero = {}
- nonzero = {}
- if a_infinity:
- nonzero.update({a.Infinity : 'a_infinite'})
- else:
- zero.update({a.Infinity : 'a_finite'})
- zz = a.Z^2
- u1 = a.X
- u2 = b.X * zz
- s1 = a.Y
- s2 = b.Y * zz
- s2 = s2 * a.Z
- z = a.Z
- t = u1
- t = t + u2
- m = s1
- m = m + s2
- n = m^2
- q = n * t
- n = n^2
- rr = t^2
- t = u1 * u2
- t = -t
- rr = rr + t
- t = rr^2
- rz = m * z
- infinity = False
- if (branch & 2) != 0:
- if not a_infinity:
- infinity = True
- else:
- return (constraints(zero={b.Z - 1 : 'b.z=1', b.Infinity : 'b_finite'}), constraints(nonzero={z : 'conflict_a'}, zero={z : 'conflict_b'}), point_at_infinity())
- zero.update({rz : 'r.z=0'})
- else:
- nonzero.update({rz : 'r.z!=0'})
- rz = rz * (0 if a_infinity else 2)
- rx = t
- q = -q
- rx = rx + q
- q = q * 3
- t = t * 2
- t = t + q
- t = t * rr
- t = t + n
- ry = -t
- rx = rx * (0 if a_infinity else 4)
- ry = ry * (0 if a_infinity else 4)
- t = b.X
- t = t * (1 if a_infinity else 0)
- rx = rx + t
- t = b.Y
- t = t * (1 if a_infinity else 0)
- ry = ry + t
- t = (1 if a_infinity else 0)
- rz = rz + t
- if infinity:
- return (constraints(zero={b.Z - 1 : 'b.z=1', b.Infinity : 'b_finite'}), constraints(zero=zero, nonzero=nonzero), point_at_infinity())
- return (constraints(zero={b.Z - 1 : 'b.z=1', b.Infinity : 'b_finite'}), constraints(zero=zero, nonzero=nonzero), jacobianpoint(rx, ry, rz))
-
-if __name__ == "__main__":
- check_symbolic_jacobian_weierstrass("secp256k1_gej_add_var", 0, 7, 5, formula_secp256k1_gej_add_var)
- check_symbolic_jacobian_weierstrass("secp256k1_gej_add_ge_var", 0, 7, 5, formula_secp256k1_gej_add_ge_var)
- check_symbolic_jacobian_weierstrass("secp256k1_gej_add_zinv_var", 0, 7, 5, formula_secp256k1_gej_add_zinv_var)
- check_symbolic_jacobian_weierstrass("secp256k1_gej_add_ge", 0, 7, 16, formula_secp256k1_gej_add_ge)
- check_symbolic_jacobian_weierstrass("secp256k1_gej_add_ge_old [should fail]", 0, 7, 4, formula_secp256k1_gej_add_ge_old)
-
- if len(sys.argv) >= 2 and sys.argv[1] == "--exhaustive":
- check_exhaustive_jacobian_weierstrass("secp256k1_gej_add_var", 0, 7, 5, formula_secp256k1_gej_add_var, 43)
- check_exhaustive_jacobian_weierstrass("secp256k1_gej_add_ge_var", 0, 7, 5, formula_secp256k1_gej_add_ge_var, 43)
- check_exhaustive_jacobian_weierstrass("secp256k1_gej_add_zinv_var", 0, 7, 5, formula_secp256k1_gej_add_zinv_var, 43)
- check_exhaustive_jacobian_weierstrass("secp256k1_gej_add_ge", 0, 7, 16, formula_secp256k1_gej_add_ge, 43)
- check_exhaustive_jacobian_weierstrass("secp256k1_gej_add_ge_old [should fail]", 0, 7, 4, formula_secp256k1_gej_add_ge_old, 43)
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/sage/weierstrass_prover.sage op-geth/crypto/secp256k1/libsecp256k1/sage/weierstrass_prover.sage
deleted file mode 100644
index 03ef2ec901ea9cafa47b4ccdce7bbba61279930f..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/sage/weierstrass_prover.sage
+++ /dev/null
@@ -1,264 +0,0 @@
-# Prover implementation for Weierstrass curves of the form
-# y^2 = x^3 + A * x + B, specifically with a = 0 and b = 7, with group laws
-# operating on affine and Jacobian coordinates, including the point at infinity
-# represented by a 4th variable in coordinates.
-
-load("group_prover.sage")
-
-
-class affinepoint:
- def __init__(self, x, y, infinity=0):
- self.x = x
- self.y = y
- self.infinity = infinity
- def __str__(self):
- return "affinepoint(x=%s,y=%s,inf=%s)" % (self.x, self.y, self.infinity)
-
-
-class jacobianpoint:
- def __init__(self, x, y, z, infinity=0):
- self.X = x
- self.Y = y
- self.Z = z
- self.Infinity = infinity
- def __str__(self):
- return "jacobianpoint(X=%s,Y=%s,Z=%s,inf=%s)" % (self.X, self.Y, self.Z, self.Infinity)
-
-
-def point_at_infinity():
- return jacobianpoint(1, 1, 1, 1)
-
-
-def negate(p):
- if p.__class__ == affinepoint:
- return affinepoint(p.x, -p.y)
- if p.__class__ == jacobianpoint:
- return jacobianpoint(p.X, -p.Y, p.Z)
- assert(False)
-
-
-def on_weierstrass_curve(A, B, p):
- """Return a set of zero-expressions for an affine point to be on the curve"""
- return constraints(zero={p.x^3 + A*p.x + B - p.y^2: 'on_curve'})
-
-
-def tangential_to_weierstrass_curve(A, B, p12, p3):
- """Return a set of zero-expressions for ((x12,y12),(x3,y3)) to be a line that is tangential to the curve at (x12,y12)"""
- return constraints(zero={
- (p12.y - p3.y) * (p12.y * 2) - (p12.x^2 * 3 + A) * (p12.x - p3.x): 'tangential_to_curve'
- })
-
-
-def colinear(p1, p2, p3):
- """Return a set of zero-expressions for ((x1,y1),(x2,y2),(x3,y3)) to be collinear"""
- return constraints(zero={
- (p1.y - p2.y) * (p1.x - p3.x) - (p1.y - p3.y) * (p1.x - p2.x): 'colinear_1',
- (p2.y - p3.y) * (p2.x - p1.x) - (p2.y - p1.y) * (p2.x - p3.x): 'colinear_2',
- (p3.y - p1.y) * (p3.x - p2.x) - (p3.y - p2.y) * (p3.x - p1.x): 'colinear_3'
- })
-
-
-def good_affine_point(p):
- return constraints(nonzero={p.x : 'nonzero_x', p.y : 'nonzero_y'})
-
-
-def good_jacobian_point(p):
- return constraints(nonzero={p.X : 'nonzero_X', p.Y : 'nonzero_Y', p.Z^6 : 'nonzero_Z'})
-
-
-def good_point(p):
- return constraints(nonzero={p.Z^6 : 'nonzero_X'})
-
-
-def finite(p, *affine_fns):
- con = good_point(p) + constraints(zero={p.Infinity : 'finite_point'})
- if p.Z != 0:
- return con + reduce(lambda a, b: a + b, (f(affinepoint(p.X / p.Z^2, p.Y / p.Z^3)) for f in affine_fns), con)
- else:
- return con
-
-def infinite(p):
- return constraints(nonzero={p.Infinity : 'infinite_point'})
-
-
-def law_jacobian_weierstrass_add(A, B, pa, pb, pA, pB, pC):
- """Check whether the passed set of coordinates is a valid Jacobian add, given assumptions"""
- assumeLaw = (good_affine_point(pa) +
- good_affine_point(pb) +
- good_jacobian_point(pA) +
- good_jacobian_point(pB) +
- on_weierstrass_curve(A, B, pa) +
- on_weierstrass_curve(A, B, pb) +
- finite(pA) +
- finite(pB) +
- constraints(nonzero={pa.x - pb.x : 'different_x'}))
- require = (finite(pC, lambda pc: on_weierstrass_curve(A, B, pc) +
- colinear(pa, pb, negate(pc))))
- return (assumeLaw, require)
-
-
-def law_jacobian_weierstrass_double(A, B, pa, pb, pA, pB, pC):
- """Check whether the passed set of coordinates is a valid Jacobian doubling, given assumptions"""
- assumeLaw = (good_affine_point(pa) +
- good_affine_point(pb) +
- good_jacobian_point(pA) +
- good_jacobian_point(pB) +
- on_weierstrass_curve(A, B, pa) +
- on_weierstrass_curve(A, B, pb) +
- finite(pA) +
- finite(pB) +
- constraints(zero={pa.x - pb.x : 'equal_x', pa.y - pb.y : 'equal_y'}))
- require = (finite(pC, lambda pc: on_weierstrass_curve(A, B, pc) +
- tangential_to_weierstrass_curve(A, B, pa, negate(pc))))
- return (assumeLaw, require)
-
-
-def law_jacobian_weierstrass_add_opposites(A, B, pa, pb, pA, pB, pC):
- assumeLaw = (good_affine_point(pa) +
- good_affine_point(pb) +
- good_jacobian_point(pA) +
- good_jacobian_point(pB) +
- on_weierstrass_curve(A, B, pa) +
- on_weierstrass_curve(A, B, pb) +
- finite(pA) +
- finite(pB) +
- constraints(zero={pa.x - pb.x : 'equal_x', pa.y + pb.y : 'opposite_y'}))
- require = infinite(pC)
- return (assumeLaw, require)
-
-
-def law_jacobian_weierstrass_add_infinite_a(A, B, pa, pb, pA, pB, pC):
- assumeLaw = (good_affine_point(pa) +
- good_affine_point(pb) +
- good_jacobian_point(pA) +
- good_jacobian_point(pB) +
- on_weierstrass_curve(A, B, pb) +
- infinite(pA) +
- finite(pB))
- require = finite(pC, lambda pc: constraints(zero={pc.x - pb.x : 'c.x=b.x', pc.y - pb.y : 'c.y=b.y'}))
- return (assumeLaw, require)
-
-
-def law_jacobian_weierstrass_add_infinite_b(A, B, pa, pb, pA, pB, pC):
- assumeLaw = (good_affine_point(pa) +
- good_affine_point(pb) +
- good_jacobian_point(pA) +
- good_jacobian_point(pB) +
- on_weierstrass_curve(A, B, pa) +
- infinite(pB) +
- finite(pA))
- require = finite(pC, lambda pc: constraints(zero={pc.x - pa.x : 'c.x=a.x', pc.y - pa.y : 'c.y=a.y'}))
- return (assumeLaw, require)
-
-
-def law_jacobian_weierstrass_add_infinite_ab(A, B, pa, pb, pA, pB, pC):
- assumeLaw = (good_affine_point(pa) +
- good_affine_point(pb) +
- good_jacobian_point(pA) +
- good_jacobian_point(pB) +
- infinite(pA) +
- infinite(pB))
- require = infinite(pC)
- return (assumeLaw, require)
-
-
-laws_jacobian_weierstrass = {
- 'add': law_jacobian_weierstrass_add,
- 'double': law_jacobian_weierstrass_double,
- 'add_opposite': law_jacobian_weierstrass_add_opposites,
- 'add_infinite_a': law_jacobian_weierstrass_add_infinite_a,
- 'add_infinite_b': law_jacobian_weierstrass_add_infinite_b,
- 'add_infinite_ab': law_jacobian_weierstrass_add_infinite_ab
-}
-
-
-def check_exhaustive_jacobian_weierstrass(name, A, B, branches, formula, p):
- """Verify an implementation of addition of Jacobian points on a Weierstrass curve, by executing and validating the result for every possible addition in a prime field"""
- F = Integers(p)
- print "Formula %s on Z%i:" % (name, p)
- points = []
- for x in xrange(0, p):
- for y in xrange(0, p):
- point = affinepoint(F(x), F(y))
- r, e = concrete_verify(on_weierstrass_curve(A, B, point))
- if r:
- points.append(point)
-
- for za in xrange(1, p):
- for zb in xrange(1, p):
- for pa in points:
- for pb in points:
- for ia in xrange(2):
- for ib in xrange(2):
- pA = jacobianpoint(pa.x * F(za)^2, pa.y * F(za)^3, F(za), ia)
- pB = jacobianpoint(pb.x * F(zb)^2, pb.y * F(zb)^3, F(zb), ib)
- for branch in xrange(0, branches):
- assumeAssert, assumeBranch, pC = formula(branch, pA, pB)
- pC.X = F(pC.X)
- pC.Y = F(pC.Y)
- pC.Z = F(pC.Z)
- pC.Infinity = F(pC.Infinity)
- r, e = concrete_verify(assumeAssert + assumeBranch)
- if r:
- match = False
- for key in laws_jacobian_weierstrass:
- assumeLaw, require = laws_jacobian_weierstrass[key](A, B, pa, pb, pA, pB, pC)
- r, e = concrete_verify(assumeLaw)
- if r:
- if match:
- print " multiple branches for (%s,%s,%s,%s) + (%s,%s,%s,%s)" % (pA.X, pA.Y, pA.Z, pA.Infinity, pB.X, pB.Y, pB.Z, pB.Infinity)
- else:
- match = True
- r, e = concrete_verify(require)
- if not r:
- print " failure in branch %i for (%s,%s,%s,%s) + (%s,%s,%s,%s) = (%s,%s,%s,%s): %s" % (branch, pA.X, pA.Y, pA.Z, pA.Infinity, pB.X, pB.Y, pB.Z, pB.Infinity, pC.X, pC.Y, pC.Z, pC.Infinity, e)
- print
-
-
-def check_symbolic_function(R, assumeAssert, assumeBranch, f, A, B, pa, pb, pA, pB, pC):
- assumeLaw, require = f(A, B, pa, pb, pA, pB, pC)
- return check_symbolic(R, assumeLaw, assumeAssert, assumeBranch, require)
-
-def check_symbolic_jacobian_weierstrass(name, A, B, branches, formula):
- """Verify an implementation of addition of Jacobian points on a Weierstrass curve symbolically"""
- R.<ax,bx,ay,by,Az,Bz,Ai,Bi> = PolynomialRing(QQ,8,order='invlex')
- lift = lambda x: fastfrac(R,x)
- ax = lift(ax)
- ay = lift(ay)
- Az = lift(Az)
- bx = lift(bx)
- by = lift(by)
- Bz = lift(Bz)
- Ai = lift(Ai)
- Bi = lift(Bi)
-
- pa = affinepoint(ax, ay, Ai)
- pb = affinepoint(bx, by, Bi)
- pA = jacobianpoint(ax * Az^2, ay * Az^3, Az, Ai)
- pB = jacobianpoint(bx * Bz^2, by * Bz^3, Bz, Bi)
-
- res = {}
-
- for key in laws_jacobian_weierstrass:
- res[key] = []
-
- print ("Formula " + name + ":")
- count = 0
- for branch in xrange(branches):
- assumeFormula, assumeBranch, pC = formula(branch, pA, pB)
- pC.X = lift(pC.X)
- pC.Y = lift(pC.Y)
- pC.Z = lift(pC.Z)
- pC.Infinity = lift(pC.Infinity)
-
- for key in laws_jacobian_weierstrass:
- res[key].append((check_symbolic_function(R, assumeFormula, assumeBranch, laws_jacobian_weierstrass[key], A, B, pa, pb, pA, pB, pC), branch))
-
- for key in res:
- print " %s:" % key
- val = res[key]
- for x in val:
- if x[0] is not None:
- print " branch %i: %s" % (x[1], x[0])
-
- print
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/asm/field_10x26_arm.s op-geth/crypto/secp256k1/libsecp256k1/src/asm/field_10x26_arm.s
deleted file mode 100644
index 5a9cc3ffcfdaf200779eea6082b5168e8311211c..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/asm/field_10x26_arm.s
+++ /dev/null
@@ -1,919 +0,0 @@
-@ vim: set tabstop=8 softtabstop=8 shiftwidth=8 noexpandtab syntax=armasm:
-/**********************************************************************
- * Copyright (c) 2014 Wladimir J. van der Laan *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-/*
-ARM implementation of field_10x26 inner loops.
-
-Note:
-
-- To avoid unnecessary loads and make use of available registers, two
- 'passes' have every time been interleaved, with the odd passes accumulating c' and d'
- which will be added to c and d respectively in the even passes
-
-*/
-
- .syntax unified
- .arch armv7-a
- @ eabi attributes - see readelf -A
- .eabi_attribute 8, 1 @ Tag_ARM_ISA_use = yes
- .eabi_attribute 9, 0 @ Tag_Thumb_ISA_use = no
- .eabi_attribute 10, 0 @ Tag_FP_arch = none
- .eabi_attribute 24, 1 @ Tag_ABI_align_needed = 8-byte
- .eabi_attribute 25, 1 @ Tag_ABI_align_preserved = 8-byte, except leaf SP
- .eabi_attribute 30, 2 @ Tag_ABI_optimization_goals = Aggressive Speed
- .eabi_attribute 34, 1 @ Tag_CPU_unaligned_access = v6
- .text
-
- @ Field constants
- .set field_R0, 0x3d10
- .set field_R1, 0x400
- .set field_not_M, 0xfc000000 @ ~M = ~0x3ffffff
-
- .align 2
- .global secp256k1_fe_mul_inner
- .type secp256k1_fe_mul_inner, %function
- @ Arguments:
- @ r0 r Restrict: can overlap with a, not with b
- @ r1 a
- @ r2 b
- @ Stack (total 4+10*4 = 44)
- @ sp + #0 saved 'r' pointer
- @ sp + #4 + 4*X t0,t1,t2,t3,t4,t5,t6,t7,u8,t9
-secp256k1_fe_mul_inner:
- stmfd sp!, {r4, r5, r6, r7, r8, r9, r10, r11, r14}
- sub sp, sp, #48 @ frame=44 + alignment
- str r0, [sp, #0] @ save result address, we need it only at the end
-
- /******************************************
- * Main computation code.
- ******************************************
-
- Allocation:
- r0,r14,r7,r8 scratch
- r1 a (pointer)
- r2 b (pointer)
- r3:r4 c
- r5:r6 d
- r11:r12 c'
- r9:r10 d'
-
- Note: do not write to r[] here, it may overlap with a[]
- */
-
- /* A - interleaved with B */
- ldr r7, [r1, #0*4] @ a[0]
- ldr r8, [r2, #9*4] @ b[9]
- ldr r0, [r1, #1*4] @ a[1]
- umull r5, r6, r7, r8 @ d = a[0] * b[9]
- ldr r14, [r2, #8*4] @ b[8]
- umull r9, r10, r0, r8 @ d' = a[1] * b[9]
- ldr r7, [r1, #2*4] @ a[2]
- umlal r5, r6, r0, r14 @ d += a[1] * b[8]
- ldr r8, [r2, #7*4] @ b[7]
- umlal r9, r10, r7, r14 @ d' += a[2] * b[8]
- ldr r0, [r1, #3*4] @ a[3]
- umlal r5, r6, r7, r8 @ d += a[2] * b[7]
- ldr r14, [r2, #6*4] @ b[6]
- umlal r9, r10, r0, r8 @ d' += a[3] * b[7]
- ldr r7, [r1, #4*4] @ a[4]
- umlal r5, r6, r0, r14 @ d += a[3] * b[6]
- ldr r8, [r2, #5*4] @ b[5]
- umlal r9, r10, r7, r14 @ d' += a[4] * b[6]
- ldr r0, [r1, #5*4] @ a[5]
- umlal r5, r6, r7, r8 @ d += a[4] * b[5]
- ldr r14, [r2, #4*4] @ b[4]
- umlal r9, r10, r0, r8 @ d' += a[5] * b[5]
- ldr r7, [r1, #6*4] @ a[6]
- umlal r5, r6, r0, r14 @ d += a[5] * b[4]
- ldr r8, [r2, #3*4] @ b[3]
- umlal r9, r10, r7, r14 @ d' += a[6] * b[4]
- ldr r0, [r1, #7*4] @ a[7]
- umlal r5, r6, r7, r8 @ d += a[6] * b[3]
- ldr r14, [r2, #2*4] @ b[2]
- umlal r9, r10, r0, r8 @ d' += a[7] * b[3]
- ldr r7, [r1, #8*4] @ a[8]
- umlal r5, r6, r0, r14 @ d += a[7] * b[2]
- ldr r8, [r2, #1*4] @ b[1]
- umlal r9, r10, r7, r14 @ d' += a[8] * b[2]
- ldr r0, [r1, #9*4] @ a[9]
- umlal r5, r6, r7, r8 @ d += a[8] * b[1]
- ldr r14, [r2, #0*4] @ b[0]
- umlal r9, r10, r0, r8 @ d' += a[9] * b[1]
- ldr r7, [r1, #0*4] @ a[0]
- umlal r5, r6, r0, r14 @ d += a[9] * b[0]
- @ r7,r14 used in B
-
- bic r0, r5, field_not_M @ t9 = d & M
- str r0, [sp, #4 + 4*9]
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
-
- /* B */
- umull r3, r4, r7, r14 @ c = a[0] * b[0]
- adds r5, r5, r9 @ d += d'
- adc r6, r6, r10
-
- bic r0, r5, field_not_M @ u0 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u0 * R0
- umlal r3, r4, r0, r14
-
- bic r14, r3, field_not_M @ t0 = c & M
- str r14, [sp, #4 + 0*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u0 * R1
- umlal r3, r4, r0, r14
-
- /* C - interleaved with D */
- ldr r7, [r1, #0*4] @ a[0]
- ldr r8, [r2, #2*4] @ b[2]
- ldr r14, [r2, #1*4] @ b[1]
- umull r11, r12, r7, r8 @ c' = a[0] * b[2]
- ldr r0, [r1, #1*4] @ a[1]
- umlal r3, r4, r7, r14 @ c += a[0] * b[1]
- ldr r8, [r2, #0*4] @ b[0]
- umlal r11, r12, r0, r14 @ c' += a[1] * b[1]
- ldr r7, [r1, #2*4] @ a[2]
- umlal r3, r4, r0, r8 @ c += a[1] * b[0]
- ldr r14, [r2, #9*4] @ b[9]
- umlal r11, r12, r7, r8 @ c' += a[2] * b[0]
- ldr r0, [r1, #3*4] @ a[3]
- umlal r5, r6, r7, r14 @ d += a[2] * b[9]
- ldr r8, [r2, #8*4] @ b[8]
- umull r9, r10, r0, r14 @ d' = a[3] * b[9]
- ldr r7, [r1, #4*4] @ a[4]
- umlal r5, r6, r0, r8 @ d += a[3] * b[8]
- ldr r14, [r2, #7*4] @ b[7]
- umlal r9, r10, r7, r8 @ d' += a[4] * b[8]
- ldr r0, [r1, #5*4] @ a[5]
- umlal r5, r6, r7, r14 @ d += a[4] * b[7]
- ldr r8, [r2, #6*4] @ b[6]
- umlal r9, r10, r0, r14 @ d' += a[5] * b[7]
- ldr r7, [r1, #6*4] @ a[6]
- umlal r5, r6, r0, r8 @ d += a[5] * b[6]
- ldr r14, [r2, #5*4] @ b[5]
- umlal r9, r10, r7, r8 @ d' += a[6] * b[6]
- ldr r0, [r1, #7*4] @ a[7]
- umlal r5, r6, r7, r14 @ d += a[6] * b[5]
- ldr r8, [r2, #4*4] @ b[4]
- umlal r9, r10, r0, r14 @ d' += a[7] * b[5]
- ldr r7, [r1, #8*4] @ a[8]
- umlal r5, r6, r0, r8 @ d += a[7] * b[4]
- ldr r14, [r2, #3*4] @ b[3]
- umlal r9, r10, r7, r8 @ d' += a[8] * b[4]
- ldr r0, [r1, #9*4] @ a[9]
- umlal r5, r6, r7, r14 @ d += a[8] * b[3]
- ldr r8, [r2, #2*4] @ b[2]
- umlal r9, r10, r0, r14 @ d' += a[9] * b[3]
- umlal r5, r6, r0, r8 @ d += a[9] * b[2]
-
- bic r0, r5, field_not_M @ u1 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u1 * R0
- umlal r3, r4, r0, r14
-
- bic r14, r3, field_not_M @ t1 = c & M
- str r14, [sp, #4 + 1*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u1 * R1
- umlal r3, r4, r0, r14
-
- /* D */
- adds r3, r3, r11 @ c += c'
- adc r4, r4, r12
- adds r5, r5, r9 @ d += d'
- adc r6, r6, r10
-
- bic r0, r5, field_not_M @ u2 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u2 * R0
- umlal r3, r4, r0, r14
-
- bic r14, r3, field_not_M @ t2 = c & M
- str r14, [sp, #4 + 2*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u2 * R1
- umlal r3, r4, r0, r14
-
- /* E - interleaved with F */
- ldr r7, [r1, #0*4] @ a[0]
- ldr r8, [r2, #4*4] @ b[4]
- umull r11, r12, r7, r8 @ c' = a[0] * b[4]
- ldr r8, [r2, #3*4] @ b[3]
- umlal r3, r4, r7, r8 @ c += a[0] * b[3]
- ldr r7, [r1, #1*4] @ a[1]
- umlal r11, r12, r7, r8 @ c' += a[1] * b[3]
- ldr r8, [r2, #2*4] @ b[2]
- umlal r3, r4, r7, r8 @ c += a[1] * b[2]
- ldr r7, [r1, #2*4] @ a[2]
- umlal r11, r12, r7, r8 @ c' += a[2] * b[2]
- ldr r8, [r2, #1*4] @ b[1]
- umlal r3, r4, r7, r8 @ c += a[2] * b[1]
- ldr r7, [r1, #3*4] @ a[3]
- umlal r11, r12, r7, r8 @ c' += a[3] * b[1]
- ldr r8, [r2, #0*4] @ b[0]
- umlal r3, r4, r7, r8 @ c += a[3] * b[0]
- ldr r7, [r1, #4*4] @ a[4]
- umlal r11, r12, r7, r8 @ c' += a[4] * b[0]
- ldr r8, [r2, #9*4] @ b[9]
- umlal r5, r6, r7, r8 @ d += a[4] * b[9]
- ldr r7, [r1, #5*4] @ a[5]
- umull r9, r10, r7, r8 @ d' = a[5] * b[9]
- ldr r8, [r2, #8*4] @ b[8]
- umlal r5, r6, r7, r8 @ d += a[5] * b[8]
- ldr r7, [r1, #6*4] @ a[6]
- umlal r9, r10, r7, r8 @ d' += a[6] * b[8]
- ldr r8, [r2, #7*4] @ b[7]
- umlal r5, r6, r7, r8 @ d += a[6] * b[7]
- ldr r7, [r1, #7*4] @ a[7]
- umlal r9, r10, r7, r8 @ d' += a[7] * b[7]
- ldr r8, [r2, #6*4] @ b[6]
- umlal r5, r6, r7, r8 @ d += a[7] * b[6]
- ldr r7, [r1, #8*4] @ a[8]
- umlal r9, r10, r7, r8 @ d' += a[8] * b[6]
- ldr r8, [r2, #5*4] @ b[5]
- umlal r5, r6, r7, r8 @ d += a[8] * b[5]
- ldr r7, [r1, #9*4] @ a[9]
- umlal r9, r10, r7, r8 @ d' += a[9] * b[5]
- ldr r8, [r2, #4*4] @ b[4]
- umlal r5, r6, r7, r8 @ d += a[9] * b[4]
-
- bic r0, r5, field_not_M @ u3 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u3 * R0
- umlal r3, r4, r0, r14
-
- bic r14, r3, field_not_M @ t3 = c & M
- str r14, [sp, #4 + 3*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u3 * R1
- umlal r3, r4, r0, r14
-
- /* F */
- adds r3, r3, r11 @ c += c'
- adc r4, r4, r12
- adds r5, r5, r9 @ d += d'
- adc r6, r6, r10
-
- bic r0, r5, field_not_M @ u4 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u4 * R0
- umlal r3, r4, r0, r14
-
- bic r14, r3, field_not_M @ t4 = c & M
- str r14, [sp, #4 + 4*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u4 * R1
- umlal r3, r4, r0, r14
-
- /* G - interleaved with H */
- ldr r7, [r1, #0*4] @ a[0]
- ldr r8, [r2, #6*4] @ b[6]
- ldr r14, [r2, #5*4] @ b[5]
- umull r11, r12, r7, r8 @ c' = a[0] * b[6]
- ldr r0, [r1, #1*4] @ a[1]
- umlal r3, r4, r7, r14 @ c += a[0] * b[5]
- ldr r8, [r2, #4*4] @ b[4]
- umlal r11, r12, r0, r14 @ c' += a[1] * b[5]
- ldr r7, [r1, #2*4] @ a[2]
- umlal r3, r4, r0, r8 @ c += a[1] * b[4]
- ldr r14, [r2, #3*4] @ b[3]
- umlal r11, r12, r7, r8 @ c' += a[2] * b[4]
- ldr r0, [r1, #3*4] @ a[3]
- umlal r3, r4, r7, r14 @ c += a[2] * b[3]
- ldr r8, [r2, #2*4] @ b[2]
- umlal r11, r12, r0, r14 @ c' += a[3] * b[3]
- ldr r7, [r1, #4*4] @ a[4]
- umlal r3, r4, r0, r8 @ c += a[3] * b[2]
- ldr r14, [r2, #1*4] @ b[1]
- umlal r11, r12, r7, r8 @ c' += a[4] * b[2]
- ldr r0, [r1, #5*4] @ a[5]
- umlal r3, r4, r7, r14 @ c += a[4] * b[1]
- ldr r8, [r2, #0*4] @ b[0]
- umlal r11, r12, r0, r14 @ c' += a[5] * b[1]
- ldr r7, [r1, #6*4] @ a[6]
- umlal r3, r4, r0, r8 @ c += a[5] * b[0]
- ldr r14, [r2, #9*4] @ b[9]
- umlal r11, r12, r7, r8 @ c' += a[6] * b[0]
- ldr r0, [r1, #7*4] @ a[7]
- umlal r5, r6, r7, r14 @ d += a[6] * b[9]
- ldr r8, [r2, #8*4] @ b[8]
- umull r9, r10, r0, r14 @ d' = a[7] * b[9]
- ldr r7, [r1, #8*4] @ a[8]
- umlal r5, r6, r0, r8 @ d += a[7] * b[8]
- ldr r14, [r2, #7*4] @ b[7]
- umlal r9, r10, r7, r8 @ d' += a[8] * b[8]
- ldr r0, [r1, #9*4] @ a[9]
- umlal r5, r6, r7, r14 @ d += a[8] * b[7]
- ldr r8, [r2, #6*4] @ b[6]
- umlal r9, r10, r0, r14 @ d' += a[9] * b[7]
- umlal r5, r6, r0, r8 @ d += a[9] * b[6]
-
- bic r0, r5, field_not_M @ u5 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u5 * R0
- umlal r3, r4, r0, r14
-
- bic r14, r3, field_not_M @ t5 = c & M
- str r14, [sp, #4 + 5*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u5 * R1
- umlal r3, r4, r0, r14
-
- /* H */
- adds r3, r3, r11 @ c += c'
- adc r4, r4, r12
- adds r5, r5, r9 @ d += d'
- adc r6, r6, r10
-
- bic r0, r5, field_not_M @ u6 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u6 * R0
- umlal r3, r4, r0, r14
-
- bic r14, r3, field_not_M @ t6 = c & M
- str r14, [sp, #4 + 6*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u6 * R1
- umlal r3, r4, r0, r14
-
- /* I - interleaved with J */
- ldr r8, [r2, #8*4] @ b[8]
- ldr r7, [r1, #0*4] @ a[0]
- ldr r14, [r2, #7*4] @ b[7]
- umull r11, r12, r7, r8 @ c' = a[0] * b[8]
- ldr r0, [r1, #1*4] @ a[1]
- umlal r3, r4, r7, r14 @ c += a[0] * b[7]
- ldr r8, [r2, #6*4] @ b[6]
- umlal r11, r12, r0, r14 @ c' += a[1] * b[7]
- ldr r7, [r1, #2*4] @ a[2]
- umlal r3, r4, r0, r8 @ c += a[1] * b[6]
- ldr r14, [r2, #5*4] @ b[5]
- umlal r11, r12, r7, r8 @ c' += a[2] * b[6]
- ldr r0, [r1, #3*4] @ a[3]
- umlal r3, r4, r7, r14 @ c += a[2] * b[5]
- ldr r8, [r2, #4*4] @ b[4]
- umlal r11, r12, r0, r14 @ c' += a[3] * b[5]
- ldr r7, [r1, #4*4] @ a[4]
- umlal r3, r4, r0, r8 @ c += a[3] * b[4]
- ldr r14, [r2, #3*4] @ b[3]
- umlal r11, r12, r7, r8 @ c' += a[4] * b[4]
- ldr r0, [r1, #5*4] @ a[5]
- umlal r3, r4, r7, r14 @ c += a[4] * b[3]
- ldr r8, [r2, #2*4] @ b[2]
- umlal r11, r12, r0, r14 @ c' += a[5] * b[3]
- ldr r7, [r1, #6*4] @ a[6]
- umlal r3, r4, r0, r8 @ c += a[5] * b[2]
- ldr r14, [r2, #1*4] @ b[1]
- umlal r11, r12, r7, r8 @ c' += a[6] * b[2]
- ldr r0, [r1, #7*4] @ a[7]
- umlal r3, r4, r7, r14 @ c += a[6] * b[1]
- ldr r8, [r2, #0*4] @ b[0]
- umlal r11, r12, r0, r14 @ c' += a[7] * b[1]
- ldr r7, [r1, #8*4] @ a[8]
- umlal r3, r4, r0, r8 @ c += a[7] * b[0]
- ldr r14, [r2, #9*4] @ b[9]
- umlal r11, r12, r7, r8 @ c' += a[8] * b[0]
- ldr r0, [r1, #9*4] @ a[9]
- umlal r5, r6, r7, r14 @ d += a[8] * b[9]
- ldr r8, [r2, #8*4] @ b[8]
- umull r9, r10, r0, r14 @ d' = a[9] * b[9]
- umlal r5, r6, r0, r8 @ d += a[9] * b[8]
-
- bic r0, r5, field_not_M @ u7 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u7 * R0
- umlal r3, r4, r0, r14
-
- bic r14, r3, field_not_M @ t7 = c & M
- str r14, [sp, #4 + 7*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u7 * R1
- umlal r3, r4, r0, r14
-
- /* J */
- adds r3, r3, r11 @ c += c'
- adc r4, r4, r12
- adds r5, r5, r9 @ d += d'
- adc r6, r6, r10
-
- bic r0, r5, field_not_M @ u8 = d & M
- str r0, [sp, #4 + 8*4]
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u8 * R0
- umlal r3, r4, r0, r14
-
- /******************************************
- * compute and write back result
- ******************************************
- Allocation:
- r0 r
- r3:r4 c
- r5:r6 d
- r7 t0
- r8 t1
- r9 t2
- r11 u8
- r12 t9
- r1,r2,r10,r14 scratch
-
- Note: do not read from a[] after here, it may overlap with r[]
- */
- ldr r0, [sp, #0]
- add r1, sp, #4 + 3*4 @ r[3..7] = t3..7, r11=u8, r12=t9
- ldmia r1, {r2,r7,r8,r9,r10,r11,r12}
- add r1, r0, #3*4
- stmia r1, {r2,r7,r8,r9,r10}
-
- bic r2, r3, field_not_M @ r[8] = c & M
- str r2, [r0, #8*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u8 * R1
- umlal r3, r4, r11, r14
- movw r14, field_R0 @ c += d * R0
- umlal r3, r4, r5, r14
- adds r3, r3, r12 @ c += t9
- adc r4, r4, #0
-
- add r1, sp, #4 + 0*4 @ r7,r8,r9 = t0,t1,t2
- ldmia r1, {r7,r8,r9}
-
- ubfx r2, r3, #0, #22 @ r[9] = c & (M >> 4)
- str r2, [r0, #9*4]
- mov r3, r3, lsr #22 @ c >>= 22
- orr r3, r3, r4, asl #10
- mov r4, r4, lsr #22
- movw r14, field_R1 << 4 @ c += d * (R1 << 4)
- umlal r3, r4, r5, r14
-
- movw r14, field_R0 >> 4 @ d = c * (R0 >> 4) + t0 (64x64 multiply+add)
- umull r5, r6, r3, r14 @ d = c.lo * (R0 >> 4)
- adds r5, r5, r7 @ d.lo += t0
- mla r6, r14, r4, r6 @ d.hi += c.hi * (R0 >> 4)
- adc r6, r6, 0 @ d.hi += carry
-
- bic r2, r5, field_not_M @ r[0] = d & M
- str r2, [r0, #0*4]
-
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
-
- movw r14, field_R1 >> 4 @ d += c * (R1 >> 4) + t1 (64x64 multiply+add)
- umull r1, r2, r3, r14 @ tmp = c.lo * (R1 >> 4)
- adds r5, r5, r8 @ d.lo += t1
- adc r6, r6, #0 @ d.hi += carry
- adds r5, r5, r1 @ d.lo += tmp.lo
- mla r2, r14, r4, r2 @ tmp.hi += c.hi * (R1 >> 4)
- adc r6, r6, r2 @ d.hi += carry + tmp.hi
-
- bic r2, r5, field_not_M @ r[1] = d & M
- str r2, [r0, #1*4]
- mov r5, r5, lsr #26 @ d >>= 26 (ignore hi)
- orr r5, r5, r6, asl #6
-
- add r5, r5, r9 @ d += t2
- str r5, [r0, #2*4] @ r[2] = d
-
- add sp, sp, #48
- ldmfd sp!, {r4, r5, r6, r7, r8, r9, r10, r11, pc}
- .size secp256k1_fe_mul_inner, .-secp256k1_fe_mul_inner
-
- .align 2
- .global secp256k1_fe_sqr_inner
- .type secp256k1_fe_sqr_inner, %function
- @ Arguments:
- @ r0 r Can overlap with a
- @ r1 a
- @ Stack (total 4+10*4 = 44)
- @ sp + #0 saved 'r' pointer
- @ sp + #4 + 4*X t0,t1,t2,t3,t4,t5,t6,t7,u8,t9
-secp256k1_fe_sqr_inner:
- stmfd sp!, {r4, r5, r6, r7, r8, r9, r10, r11, r14}
- sub sp, sp, #48 @ frame=44 + alignment
- str r0, [sp, #0] @ save result address, we need it only at the end
- /******************************************
- * Main computation code.
- ******************************************
-
- Allocation:
- r0,r14,r2,r7,r8 scratch
- r1 a (pointer)
- r3:r4 c
- r5:r6 d
- r11:r12 c'
- r9:r10 d'
-
- Note: do not write to r[] here, it may overlap with a[]
- */
- /* A interleaved with B */
- ldr r0, [r1, #1*4] @ a[1]*2
- ldr r7, [r1, #0*4] @ a[0]
- mov r0, r0, asl #1
- ldr r14, [r1, #9*4] @ a[9]
- umull r3, r4, r7, r7 @ c = a[0] * a[0]
- ldr r8, [r1, #8*4] @ a[8]
- mov r7, r7, asl #1
- umull r5, r6, r7, r14 @ d = a[0]*2 * a[9]
- ldr r7, [r1, #2*4] @ a[2]*2
- umull r9, r10, r0, r14 @ d' = a[1]*2 * a[9]
- ldr r14, [r1, #7*4] @ a[7]
- umlal r5, r6, r0, r8 @ d += a[1]*2 * a[8]
- mov r7, r7, asl #1
- ldr r0, [r1, #3*4] @ a[3]*2
- umlal r9, r10, r7, r8 @ d' += a[2]*2 * a[8]
- ldr r8, [r1, #6*4] @ a[6]
- umlal r5, r6, r7, r14 @ d += a[2]*2 * a[7]
- mov r0, r0, asl #1
- ldr r7, [r1, #4*4] @ a[4]*2
- umlal r9, r10, r0, r14 @ d' += a[3]*2 * a[7]
- ldr r14, [r1, #5*4] @ a[5]
- mov r7, r7, asl #1
- umlal r5, r6, r0, r8 @ d += a[3]*2 * a[6]
- umlal r9, r10, r7, r8 @ d' += a[4]*2 * a[6]
- umlal r5, r6, r7, r14 @ d += a[4]*2 * a[5]
- umlal r9, r10, r14, r14 @ d' += a[5] * a[5]
-
- bic r0, r5, field_not_M @ t9 = d & M
- str r0, [sp, #4 + 9*4]
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
-
- /* B */
- adds r5, r5, r9 @ d += d'
- adc r6, r6, r10
-
- bic r0, r5, field_not_M @ u0 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u0 * R0
- umlal r3, r4, r0, r14
- bic r14, r3, field_not_M @ t0 = c & M
- str r14, [sp, #4 + 0*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u0 * R1
- umlal r3, r4, r0, r14
-
- /* C interleaved with D */
- ldr r0, [r1, #0*4] @ a[0]*2
- ldr r14, [r1, #1*4] @ a[1]
- mov r0, r0, asl #1
- ldr r8, [r1, #2*4] @ a[2]
- umlal r3, r4, r0, r14 @ c += a[0]*2 * a[1]
- mov r7, r8, asl #1 @ a[2]*2
- umull r11, r12, r14, r14 @ c' = a[1] * a[1]
- ldr r14, [r1, #9*4] @ a[9]
- umlal r11, r12, r0, r8 @ c' += a[0]*2 * a[2]
- ldr r0, [r1, #3*4] @ a[3]*2
- ldr r8, [r1, #8*4] @ a[8]
- umlal r5, r6, r7, r14 @ d += a[2]*2 * a[9]
- mov r0, r0, asl #1
- ldr r7, [r1, #4*4] @ a[4]*2
- umull r9, r10, r0, r14 @ d' = a[3]*2 * a[9]
- ldr r14, [r1, #7*4] @ a[7]
- umlal r5, r6, r0, r8 @ d += a[3]*2 * a[8]
- mov r7, r7, asl #1
- ldr r0, [r1, #5*4] @ a[5]*2
- umlal r9, r10, r7, r8 @ d' += a[4]*2 * a[8]
- ldr r8, [r1, #6*4] @ a[6]
- mov r0, r0, asl #1
- umlal r5, r6, r7, r14 @ d += a[4]*2 * a[7]
- umlal r9, r10, r0, r14 @ d' += a[5]*2 * a[7]
- umlal r5, r6, r0, r8 @ d += a[5]*2 * a[6]
- umlal r9, r10, r8, r8 @ d' += a[6] * a[6]
-
- bic r0, r5, field_not_M @ u1 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u1 * R0
- umlal r3, r4, r0, r14
- bic r14, r3, field_not_M @ t1 = c & M
- str r14, [sp, #4 + 1*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u1 * R1
- umlal r3, r4, r0, r14
-
- /* D */
- adds r3, r3, r11 @ c += c'
- adc r4, r4, r12
- adds r5, r5, r9 @ d += d'
- adc r6, r6, r10
-
- bic r0, r5, field_not_M @ u2 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u2 * R0
- umlal r3, r4, r0, r14
- bic r14, r3, field_not_M @ t2 = c & M
- str r14, [sp, #4 + 2*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u2 * R1
- umlal r3, r4, r0, r14
-
- /* E interleaved with F */
- ldr r7, [r1, #0*4] @ a[0]*2
- ldr r0, [r1, #1*4] @ a[1]*2
- ldr r14, [r1, #2*4] @ a[2]
- mov r7, r7, asl #1
- ldr r8, [r1, #3*4] @ a[3]
- ldr r2, [r1, #4*4]
- umlal r3, r4, r7, r8 @ c += a[0]*2 * a[3]
- mov r0, r0, asl #1
- umull r11, r12, r7, r2 @ c' = a[0]*2 * a[4]
- mov r2, r2, asl #1 @ a[4]*2
- umlal r11, r12, r0, r8 @ c' += a[1]*2 * a[3]
- ldr r8, [r1, #9*4] @ a[9]
- umlal r3, r4, r0, r14 @ c += a[1]*2 * a[2]
- ldr r0, [r1, #5*4] @ a[5]*2
- umlal r11, r12, r14, r14 @ c' += a[2] * a[2]
- ldr r14, [r1, #8*4] @ a[8]
- mov r0, r0, asl #1
- umlal r5, r6, r2, r8 @ d += a[4]*2 * a[9]
- ldr r7, [r1, #6*4] @ a[6]*2
- umull r9, r10, r0, r8 @ d' = a[5]*2 * a[9]
- mov r7, r7, asl #1
- ldr r8, [r1, #7*4] @ a[7]
- umlal r5, r6, r0, r14 @ d += a[5]*2 * a[8]
- umlal r9, r10, r7, r14 @ d' += a[6]*2 * a[8]
- umlal r5, r6, r7, r8 @ d += a[6]*2 * a[7]
- umlal r9, r10, r8, r8 @ d' += a[7] * a[7]
-
- bic r0, r5, field_not_M @ u3 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u3 * R0
- umlal r3, r4, r0, r14
- bic r14, r3, field_not_M @ t3 = c & M
- str r14, [sp, #4 + 3*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u3 * R1
- umlal r3, r4, r0, r14
-
- /* F */
- adds r3, r3, r11 @ c += c'
- adc r4, r4, r12
- adds r5, r5, r9 @ d += d'
- adc r6, r6, r10
-
- bic r0, r5, field_not_M @ u4 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u4 * R0
- umlal r3, r4, r0, r14
- bic r14, r3, field_not_M @ t4 = c & M
- str r14, [sp, #4 + 4*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u4 * R1
- umlal r3, r4, r0, r14
-
- /* G interleaved with H */
- ldr r7, [r1, #0*4] @ a[0]*2
- ldr r0, [r1, #1*4] @ a[1]*2
- mov r7, r7, asl #1
- ldr r8, [r1, #5*4] @ a[5]
- ldr r2, [r1, #6*4] @ a[6]
- umlal r3, r4, r7, r8 @ c += a[0]*2 * a[5]
- ldr r14, [r1, #4*4] @ a[4]
- mov r0, r0, asl #1
- umull r11, r12, r7, r2 @ c' = a[0]*2 * a[6]
- ldr r7, [r1, #2*4] @ a[2]*2
- umlal r11, r12, r0, r8 @ c' += a[1]*2 * a[5]
- mov r7, r7, asl #1
- ldr r8, [r1, #3*4] @ a[3]
- umlal r3, r4, r0, r14 @ c += a[1]*2 * a[4]
- mov r0, r2, asl #1 @ a[6]*2
- umlal r11, r12, r7, r14 @ c' += a[2]*2 * a[4]
- ldr r14, [r1, #9*4] @ a[9]
- umlal r3, r4, r7, r8 @ c += a[2]*2 * a[3]
- ldr r7, [r1, #7*4] @ a[7]*2
- umlal r11, r12, r8, r8 @ c' += a[3] * a[3]
- mov r7, r7, asl #1
- ldr r8, [r1, #8*4] @ a[8]
- umlal r5, r6, r0, r14 @ d += a[6]*2 * a[9]
- umull r9, r10, r7, r14 @ d' = a[7]*2 * a[9]
- umlal r5, r6, r7, r8 @ d += a[7]*2 * a[8]
- umlal r9, r10, r8, r8 @ d' += a[8] * a[8]
-
- bic r0, r5, field_not_M @ u5 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u5 * R0
- umlal r3, r4, r0, r14
- bic r14, r3, field_not_M @ t5 = c & M
- str r14, [sp, #4 + 5*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u5 * R1
- umlal r3, r4, r0, r14
-
- /* H */
- adds r3, r3, r11 @ c += c'
- adc r4, r4, r12
- adds r5, r5, r9 @ d += d'
- adc r6, r6, r10
-
- bic r0, r5, field_not_M @ u6 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u6 * R0
- umlal r3, r4, r0, r14
- bic r14, r3, field_not_M @ t6 = c & M
- str r14, [sp, #4 + 6*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u6 * R1
- umlal r3, r4, r0, r14
-
- /* I interleaved with J */
- ldr r7, [r1, #0*4] @ a[0]*2
- ldr r0, [r1, #1*4] @ a[1]*2
- mov r7, r7, asl #1
- ldr r8, [r1, #7*4] @ a[7]
- ldr r2, [r1, #8*4] @ a[8]
- umlal r3, r4, r7, r8 @ c += a[0]*2 * a[7]
- ldr r14, [r1, #6*4] @ a[6]
- mov r0, r0, asl #1
- umull r11, r12, r7, r2 @ c' = a[0]*2 * a[8]
- ldr r7, [r1, #2*4] @ a[2]*2
- umlal r11, r12, r0, r8 @ c' += a[1]*2 * a[7]
- ldr r8, [r1, #5*4] @ a[5]
- umlal r3, r4, r0, r14 @ c += a[1]*2 * a[6]
- ldr r0, [r1, #3*4] @ a[3]*2
- mov r7, r7, asl #1
- umlal r11, r12, r7, r14 @ c' += a[2]*2 * a[6]
- ldr r14, [r1, #4*4] @ a[4]
- mov r0, r0, asl #1
- umlal r3, r4, r7, r8 @ c += a[2]*2 * a[5]
- mov r2, r2, asl #1 @ a[8]*2
- umlal r11, r12, r0, r8 @ c' += a[3]*2 * a[5]
- umlal r3, r4, r0, r14 @ c += a[3]*2 * a[4]
- umlal r11, r12, r14, r14 @ c' += a[4] * a[4]
- ldr r8, [r1, #9*4] @ a[9]
- umlal r5, r6, r2, r8 @ d += a[8]*2 * a[9]
- @ r8 will be used in J
-
- bic r0, r5, field_not_M @ u7 = d & M
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u7 * R0
- umlal r3, r4, r0, r14
- bic r14, r3, field_not_M @ t7 = c & M
- str r14, [sp, #4 + 7*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u7 * R1
- umlal r3, r4, r0, r14
-
- /* J */
- adds r3, r3, r11 @ c += c'
- adc r4, r4, r12
- umlal r5, r6, r8, r8 @ d += a[9] * a[9]
-
- bic r0, r5, field_not_M @ u8 = d & M
- str r0, [sp, #4 + 8*4]
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
- movw r14, field_R0 @ c += u8 * R0
- umlal r3, r4, r0, r14
-
- /******************************************
- * compute and write back result
- ******************************************
- Allocation:
- r0 r
- r3:r4 c
- r5:r6 d
- r7 t0
- r8 t1
- r9 t2
- r11 u8
- r12 t9
- r1,r2,r10,r14 scratch
-
- Note: do not read from a[] after here, it may overlap with r[]
- */
- ldr r0, [sp, #0]
- add r1, sp, #4 + 3*4 @ r[3..7] = t3..7, r11=u8, r12=t9
- ldmia r1, {r2,r7,r8,r9,r10,r11,r12}
- add r1, r0, #3*4
- stmia r1, {r2,r7,r8,r9,r10}
-
- bic r2, r3, field_not_M @ r[8] = c & M
- str r2, [r0, #8*4]
- mov r3, r3, lsr #26 @ c >>= 26
- orr r3, r3, r4, asl #6
- mov r4, r4, lsr #26
- mov r14, field_R1 @ c += u8 * R1
- umlal r3, r4, r11, r14
- movw r14, field_R0 @ c += d * R0
- umlal r3, r4, r5, r14
- adds r3, r3, r12 @ c += t9
- adc r4, r4, #0
-
- add r1, sp, #4 + 0*4 @ r7,r8,r9 = t0,t1,t2
- ldmia r1, {r7,r8,r9}
-
- ubfx r2, r3, #0, #22 @ r[9] = c & (M >> 4)
- str r2, [r0, #9*4]
- mov r3, r3, lsr #22 @ c >>= 22
- orr r3, r3, r4, asl #10
- mov r4, r4, lsr #22
- movw r14, field_R1 << 4 @ c += d * (R1 << 4)
- umlal r3, r4, r5, r14
-
- movw r14, field_R0 >> 4 @ d = c * (R0 >> 4) + t0 (64x64 multiply+add)
- umull r5, r6, r3, r14 @ d = c.lo * (R0 >> 4)
- adds r5, r5, r7 @ d.lo += t0
- mla r6, r14, r4, r6 @ d.hi += c.hi * (R0 >> 4)
- adc r6, r6, 0 @ d.hi += carry
-
- bic r2, r5, field_not_M @ r[0] = d & M
- str r2, [r0, #0*4]
-
- mov r5, r5, lsr #26 @ d >>= 26
- orr r5, r5, r6, asl #6
- mov r6, r6, lsr #26
-
- movw r14, field_R1 >> 4 @ d += c * (R1 >> 4) + t1 (64x64 multiply+add)
- umull r1, r2, r3, r14 @ tmp = c.lo * (R1 >> 4)
- adds r5, r5, r8 @ d.lo += t1
- adc r6, r6, #0 @ d.hi += carry
- adds r5, r5, r1 @ d.lo += tmp.lo
- mla r2, r14, r4, r2 @ tmp.hi += c.hi * (R1 >> 4)
- adc r6, r6, r2 @ d.hi += carry + tmp.hi
-
- bic r2, r5, field_not_M @ r[1] = d & M
- str r2, [r0, #1*4]
- mov r5, r5, lsr #26 @ d >>= 26 (ignore hi)
- orr r5, r5, r6, asl #6
-
- add r5, r5, r9 @ d += t2
- str r5, [r0, #2*4] @ r[2] = d
-
- add sp, sp, #48
- ldmfd sp!, {r4, r5, r6, r7, r8, r9, r10, r11, pc}
- .size secp256k1_fe_sqr_inner, .-secp256k1_fe_sqr_inner
-
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/basic-config.h op-geth/crypto/secp256k1/libsecp256k1/src/basic-config.h
deleted file mode 100644
index c4c16eb7ca7dc9313430809cfc964bf5055d2831..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/basic-config.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_BASIC_CONFIG_
-#define _SECP256K1_BASIC_CONFIG_
-
-#ifdef USE_BASIC_CONFIG
-
-#undef USE_ASM_X86_64
-#undef USE_ENDOMORPHISM
-#undef USE_FIELD_10X26
-#undef USE_FIELD_5X52
-#undef USE_FIELD_INV_BUILTIN
-#undef USE_FIELD_INV_NUM
-#undef USE_NUM_GMP
-#undef USE_NUM_NONE
-#undef USE_SCALAR_4X64
-#undef USE_SCALAR_8X32
-#undef USE_SCALAR_INV_BUILTIN
-#undef USE_SCALAR_INV_NUM
-
-#define USE_NUM_NONE 1
-#define USE_FIELD_INV_BUILTIN 1
-#define USE_SCALAR_INV_BUILTIN 1
-#define USE_FIELD_10X26 1
-#define USE_SCALAR_8X32 1
-
-#endif // USE_BASIC_CONFIG
-#endif // _SECP256K1_BASIC_CONFIG_
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/bench.h op-geth/crypto/secp256k1/libsecp256k1/src/bench.h
deleted file mode 100644
index 3a71b4aafa048d9ba79ad1fcb432139f94550a6c..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/bench.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_BENCH_H_
-#define _SECP256K1_BENCH_H_
-
-#include <stdio.h>
-#include <math.h>
-#include "sys/time.h"
-
-static double gettimedouble(void) {
- struct timeval tv;
- gettimeofday(&tv, NULL);
- return tv.tv_usec * 0.000001 + tv.tv_sec;
-}
-
-void print_number(double x) {
- double y = x;
- int c = 0;
- if (y < 0.0) {
- y = -y;
- }
- while (y < 100.0) {
- y *= 10.0;
- c++;
- }
- printf("%.*f", c, x);
-}
-
-void run_benchmark(char *name, void (*benchmark)(void*), void (*setup)(void*), void (*teardown)(void*), void* data, int count, int iter) {
- int i;
- double min = HUGE_VAL;
- double sum = 0.0;
- double max = 0.0;
- for (i = 0; i < count; i++) {
- double begin, total;
- if (setup != NULL) {
- setup(data);
- }
- begin = gettimedouble();
- benchmark(data);
- total = gettimedouble() - begin;
- if (teardown != NULL) {
- teardown(data);
- }
- if (total < min) {
- min = total;
- }
- if (total > max) {
- max = total;
- }
- sum += total;
- }
- printf("%s: min ", name);
- print_number(min * 1000000.0 / iter);
- printf("us / avg ");
- print_number((sum / count) * 1000000.0 / iter);
- printf("us / max ");
- print_number(max * 1000000.0 / iter);
- printf("us\n");
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_ecdh.c op-geth/crypto/secp256k1/libsecp256k1/src/bench_ecdh.c
deleted file mode 100644
index cde5e2dbb4e4ea1bd4fedced7ba1fecea7de8aa1..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_ecdh.c
+++ /dev/null
@@ -1,54 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Pieter Wuille, Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#include <string.h>
-
-#include "include/secp256k1.h"
-#include "include/secp256k1_ecdh.h"
-#include "util.h"
-#include "bench.h"
-
-typedef struct {
- secp256k1_context *ctx;
- secp256k1_pubkey point;
- unsigned char scalar[32];
-} bench_ecdh_t;
-
-static void bench_ecdh_setup(void* arg) {
- int i;
- bench_ecdh_t *data = (bench_ecdh_t*)arg;
- const unsigned char point[] = {
- 0x03,
- 0x54, 0x94, 0xc1, 0x5d, 0x32, 0x09, 0x97, 0x06,
- 0xc2, 0x39, 0x5f, 0x94, 0x34, 0x87, 0x45, 0xfd,
- 0x75, 0x7c, 0xe3, 0x0e, 0x4e, 0x8c, 0x90, 0xfb,
- 0xa2, 0xba, 0xd1, 0x84, 0xf8, 0x83, 0xc6, 0x9f
- };
-
- /* create a context with no capabilities */
- data->ctx = secp256k1_context_create(SECP256K1_FLAGS_TYPE_CONTEXT);
- for (i = 0; i < 32; i++) {
- data->scalar[i] = i + 1;
- }
- CHECK(secp256k1_ec_pubkey_parse(data->ctx, &data->point, point, sizeof(point)) == 1);
-}
-
-static void bench_ecdh(void* arg) {
- int i;
- unsigned char res[32];
- bench_ecdh_t *data = (bench_ecdh_t*)arg;
-
- for (i = 0; i < 20000; i++) {
- CHECK(secp256k1_ecdh(data->ctx, res, &data->point, data->scalar) == 1);
- }
-}
-
-int main(void) {
- bench_ecdh_t data;
-
- run_benchmark("ecdh", bench_ecdh, bench_ecdh_setup, NULL, &data, 10, 20000);
- return 0;
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_internal.c op-geth/crypto/secp256k1/libsecp256k1/src/bench_internal.c
deleted file mode 100644
index 0809f77bda108dacd5a9a2c6208827c985f00f54..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_internal.c
+++ /dev/null
@@ -1,382 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014-2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-#include <stdio.h>
-
-#include "include/secp256k1.h"
-
-#include "util.h"
-#include "hash_impl.h"
-#include "num_impl.h"
-#include "field_impl.h"
-#include "group_impl.h"
-#include "scalar_impl.h"
-#include "ecmult_const_impl.h"
-#include "ecmult_impl.h"
-#include "bench.h"
-#include "secp256k1.c"
-
-typedef struct {
- secp256k1_scalar scalar_x, scalar_y;
- secp256k1_fe fe_x, fe_y;
- secp256k1_ge ge_x, ge_y;
- secp256k1_gej gej_x, gej_y;
- unsigned char data[64];
- int wnaf[256];
-} bench_inv_t;
-
-void bench_setup(void* arg) {
- bench_inv_t *data = (bench_inv_t*)arg;
-
- static const unsigned char init_x[32] = {
- 0x02, 0x03, 0x05, 0x07, 0x0b, 0x0d, 0x11, 0x13,
- 0x17, 0x1d, 0x1f, 0x25, 0x29, 0x2b, 0x2f, 0x35,
- 0x3b, 0x3d, 0x43, 0x47, 0x49, 0x4f, 0x53, 0x59,
- 0x61, 0x65, 0x67, 0x6b, 0x6d, 0x71, 0x7f, 0x83
- };
-
- static const unsigned char init_y[32] = {
- 0x82, 0x83, 0x85, 0x87, 0x8b, 0x8d, 0x81, 0x83,
- 0x97, 0xad, 0xaf, 0xb5, 0xb9, 0xbb, 0xbf, 0xc5,
- 0xdb, 0xdd, 0xe3, 0xe7, 0xe9, 0xef, 0xf3, 0xf9,
- 0x11, 0x15, 0x17, 0x1b, 0x1d, 0xb1, 0xbf, 0xd3
- };
-
- secp256k1_scalar_set_b32(&data->scalar_x, init_x, NULL);
- secp256k1_scalar_set_b32(&data->scalar_y, init_y, NULL);
- secp256k1_fe_set_b32(&data->fe_x, init_x);
- secp256k1_fe_set_b32(&data->fe_y, init_y);
- CHECK(secp256k1_ge_set_xo_var(&data->ge_x, &data->fe_x, 0));
- CHECK(secp256k1_ge_set_xo_var(&data->ge_y, &data->fe_y, 1));
- secp256k1_gej_set_ge(&data->gej_x, &data->ge_x);
- secp256k1_gej_set_ge(&data->gej_y, &data->ge_y);
- memcpy(data->data, init_x, 32);
- memcpy(data->data + 32, init_y, 32);
-}
-
-void bench_scalar_add(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 2000000; i++) {
- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
- }
-}
-
-void bench_scalar_negate(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 2000000; i++) {
- secp256k1_scalar_negate(&data->scalar_x, &data->scalar_x);
- }
-}
-
-void bench_scalar_sqr(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 200000; i++) {
- secp256k1_scalar_sqr(&data->scalar_x, &data->scalar_x);
- }
-}
-
-void bench_scalar_mul(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 200000; i++) {
- secp256k1_scalar_mul(&data->scalar_x, &data->scalar_x, &data->scalar_y);
- }
-}
-
-#ifdef USE_ENDOMORPHISM
-void bench_scalar_split(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 20000; i++) {
- secp256k1_scalar l, r;
- secp256k1_scalar_split_lambda(&l, &r, &data->scalar_x);
- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
- }
-}
-#endif
-
-void bench_scalar_inverse(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 2000; i++) {
- secp256k1_scalar_inverse(&data->scalar_x, &data->scalar_x);
- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
- }
-}
-
-void bench_scalar_inverse_var(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 2000; i++) {
- secp256k1_scalar_inverse_var(&data->scalar_x, &data->scalar_x);
- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
- }
-}
-
-void bench_field_normalize(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 2000000; i++) {
- secp256k1_fe_normalize(&data->fe_x);
- }
-}
-
-void bench_field_normalize_weak(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 2000000; i++) {
- secp256k1_fe_normalize_weak(&data->fe_x);
- }
-}
-
-void bench_field_mul(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 200000; i++) {
- secp256k1_fe_mul(&data->fe_x, &data->fe_x, &data->fe_y);
- }
-}
-
-void bench_field_sqr(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 200000; i++) {
- secp256k1_fe_sqr(&data->fe_x, &data->fe_x);
- }
-}
-
-void bench_field_inverse(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 20000; i++) {
- secp256k1_fe_inv(&data->fe_x, &data->fe_x);
- secp256k1_fe_add(&data->fe_x, &data->fe_y);
- }
-}
-
-void bench_field_inverse_var(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 20000; i++) {
- secp256k1_fe_inv_var(&data->fe_x, &data->fe_x);
- secp256k1_fe_add(&data->fe_x, &data->fe_y);
- }
-}
-
-void bench_field_sqrt(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 20000; i++) {
- secp256k1_fe_sqrt(&data->fe_x, &data->fe_x);
- secp256k1_fe_add(&data->fe_x, &data->fe_y);
- }
-}
-
-void bench_group_double_var(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 200000; i++) {
- secp256k1_gej_double_var(&data->gej_x, &data->gej_x, NULL);
- }
-}
-
-void bench_group_add_var(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 200000; i++) {
- secp256k1_gej_add_var(&data->gej_x, &data->gej_x, &data->gej_y, NULL);
- }
-}
-
-void bench_group_add_affine(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 200000; i++) {
- secp256k1_gej_add_ge(&data->gej_x, &data->gej_x, &data->ge_y);
- }
-}
-
-void bench_group_add_affine_var(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 200000; i++) {
- secp256k1_gej_add_ge_var(&data->gej_x, &data->gej_x, &data->ge_y, NULL);
- }
-}
-
-void bench_group_jacobi_var(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 20000; i++) {
- secp256k1_gej_has_quad_y_var(&data->gej_x);
- }
-}
-
-void bench_ecmult_wnaf(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 20000; i++) {
- secp256k1_ecmult_wnaf(data->wnaf, 256, &data->scalar_x, WINDOW_A);
- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
- }
-}
-
-void bench_wnaf_const(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
-
- for (i = 0; i < 20000; i++) {
- secp256k1_wnaf_const(data->wnaf, data->scalar_x, WINDOW_A);
- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
- }
-}
-
-
-void bench_sha256(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
- secp256k1_sha256_t sha;
-
- for (i = 0; i < 20000; i++) {
- secp256k1_sha256_initialize(&sha);
- secp256k1_sha256_write(&sha, data->data, 32);
- secp256k1_sha256_finalize(&sha, data->data);
- }
-}
-
-void bench_hmac_sha256(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
- secp256k1_hmac_sha256_t hmac;
-
- for (i = 0; i < 20000; i++) {
- secp256k1_hmac_sha256_initialize(&hmac, data->data, 32);
- secp256k1_hmac_sha256_write(&hmac, data->data, 32);
- secp256k1_hmac_sha256_finalize(&hmac, data->data);
- }
-}
-
-void bench_rfc6979_hmac_sha256(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
- secp256k1_rfc6979_hmac_sha256_t rng;
-
- for (i = 0; i < 20000; i++) {
- secp256k1_rfc6979_hmac_sha256_initialize(&rng, data->data, 64);
- secp256k1_rfc6979_hmac_sha256_generate(&rng, data->data, 32);
- }
-}
-
-void bench_context_verify(void* arg) {
- int i;
- (void)arg;
- for (i = 0; i < 20; i++) {
- secp256k1_context_destroy(secp256k1_context_create(SECP256K1_CONTEXT_VERIFY));
- }
-}
-
-void bench_context_sign(void* arg) {
- int i;
- (void)arg;
- for (i = 0; i < 200; i++) {
- secp256k1_context_destroy(secp256k1_context_create(SECP256K1_CONTEXT_SIGN));
- }
-}
-
-#ifndef USE_NUM_NONE
-void bench_num_jacobi(void* arg) {
- int i;
- bench_inv_t *data = (bench_inv_t*)arg;
- secp256k1_num nx, norder;
-
- secp256k1_scalar_get_num(&nx, &data->scalar_x);
- secp256k1_scalar_order_get_num(&norder);
- secp256k1_scalar_get_num(&norder, &data->scalar_y);
-
- for (i = 0; i < 200000; i++) {
- secp256k1_num_jacobi(&nx, &norder);
- }
-}
-#endif
-
-int have_flag(int argc, char** argv, char *flag) {
- char** argm = argv + argc;
- argv++;
- if (argv == argm) {
- return 1;
- }
- while (argv != NULL && argv != argm) {
- if (strcmp(*argv, flag) == 0) {
- return 1;
- }
- argv++;
- }
- return 0;
-}
-
-int main(int argc, char **argv) {
- bench_inv_t data;
- if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "add")) run_benchmark("scalar_add", bench_scalar_add, bench_setup, NULL, &data, 10, 2000000);
- if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "negate")) run_benchmark("scalar_negate", bench_scalar_negate, bench_setup, NULL, &data, 10, 2000000);
- if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "sqr")) run_benchmark("scalar_sqr", bench_scalar_sqr, bench_setup, NULL, &data, 10, 200000);
- if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "mul")) run_benchmark("scalar_mul", bench_scalar_mul, bench_setup, NULL, &data, 10, 200000);
-#ifdef USE_ENDOMORPHISM
- if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "split")) run_benchmark("scalar_split", bench_scalar_split, bench_setup, NULL, &data, 10, 20000);
-#endif
- if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "inverse")) run_benchmark("scalar_inverse", bench_scalar_inverse, bench_setup, NULL, &data, 10, 2000);
- if (have_flag(argc, argv, "scalar") || have_flag(argc, argv, "inverse")) run_benchmark("scalar_inverse_var", bench_scalar_inverse_var, bench_setup, NULL, &data, 10, 2000);
-
- if (have_flag(argc, argv, "field") || have_flag(argc, argv, "normalize")) run_benchmark("field_normalize", bench_field_normalize, bench_setup, NULL, &data, 10, 2000000);
- if (have_flag(argc, argv, "field") || have_flag(argc, argv, "normalize")) run_benchmark("field_normalize_weak", bench_field_normalize_weak, bench_setup, NULL, &data, 10, 2000000);
- if (have_flag(argc, argv, "field") || have_flag(argc, argv, "sqr")) run_benchmark("field_sqr", bench_field_sqr, bench_setup, NULL, &data, 10, 200000);
- if (have_flag(argc, argv, "field") || have_flag(argc, argv, "mul")) run_benchmark("field_mul", bench_field_mul, bench_setup, NULL, &data, 10, 200000);
- if (have_flag(argc, argv, "field") || have_flag(argc, argv, "inverse")) run_benchmark("field_inverse", bench_field_inverse, bench_setup, NULL, &data, 10, 20000);
- if (have_flag(argc, argv, "field") || have_flag(argc, argv, "inverse")) run_benchmark("field_inverse_var", bench_field_inverse_var, bench_setup, NULL, &data, 10, 20000);
- if (have_flag(argc, argv, "field") || have_flag(argc, argv, "sqrt")) run_benchmark("field_sqrt", bench_field_sqrt, bench_setup, NULL, &data, 10, 20000);
-
- if (have_flag(argc, argv, "group") || have_flag(argc, argv, "double")) run_benchmark("group_double_var", bench_group_double_var, bench_setup, NULL, &data, 10, 200000);
- if (have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_var", bench_group_add_var, bench_setup, NULL, &data, 10, 200000);
- if (have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_affine", bench_group_add_affine, bench_setup, NULL, &data, 10, 200000);
- if (have_flag(argc, argv, "group") || have_flag(argc, argv, "add")) run_benchmark("group_add_affine_var", bench_group_add_affine_var, bench_setup, NULL, &data, 10, 200000);
- if (have_flag(argc, argv, "group") || have_flag(argc, argv, "jacobi")) run_benchmark("group_jacobi_var", bench_group_jacobi_var, bench_setup, NULL, &data, 10, 20000);
-
- if (have_flag(argc, argv, "ecmult") || have_flag(argc, argv, "wnaf")) run_benchmark("wnaf_const", bench_wnaf_const, bench_setup, NULL, &data, 10, 20000);
- if (have_flag(argc, argv, "ecmult") || have_flag(argc, argv, "wnaf")) run_benchmark("ecmult_wnaf", bench_ecmult_wnaf, bench_setup, NULL, &data, 10, 20000);
-
- if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "sha256")) run_benchmark("hash_sha256", bench_sha256, bench_setup, NULL, &data, 10, 20000);
- if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "hmac")) run_benchmark("hash_hmac_sha256", bench_hmac_sha256, bench_setup, NULL, &data, 10, 20000);
- if (have_flag(argc, argv, "hash") || have_flag(argc, argv, "rng6979")) run_benchmark("hash_rfc6979_hmac_sha256", bench_rfc6979_hmac_sha256, bench_setup, NULL, &data, 10, 20000);
-
- if (have_flag(argc, argv, "context") || have_flag(argc, argv, "verify")) run_benchmark("context_verify", bench_context_verify, bench_setup, NULL, &data, 10, 20);
- if (have_flag(argc, argv, "context") || have_flag(argc, argv, "sign")) run_benchmark("context_sign", bench_context_sign, bench_setup, NULL, &data, 10, 200);
-
-#ifndef USE_NUM_NONE
- if (have_flag(argc, argv, "num") || have_flag(argc, argv, "jacobi")) run_benchmark("num_jacobi", bench_num_jacobi, bench_setup, NULL, &data, 10, 200000);
-#endif
- return 0;
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_recover.c op-geth/crypto/secp256k1/libsecp256k1/src/bench_recover.c
deleted file mode 100644
index 6489378cc64ab46f79c0c35f556625ab46f5b195..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_recover.c
+++ /dev/null
@@ -1,60 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014-2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#include "include/secp256k1.h"
-#include "include/secp256k1_recovery.h"
-#include "util.h"
-#include "bench.h"
-
-typedef struct {
- secp256k1_context *ctx;
- unsigned char msg[32];
- unsigned char sig[64];
-} bench_recover_t;
-
-void bench_recover(void* arg) {
- int i;
- bench_recover_t *data = (bench_recover_t*)arg;
- secp256k1_pubkey pubkey;
- unsigned char pubkeyc[33];
-
- for (i = 0; i < 20000; i++) {
- int j;
- size_t pubkeylen = 33;
- secp256k1_ecdsa_recoverable_signature sig;
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(data->ctx, &sig, data->sig, i % 2));
- CHECK(secp256k1_ecdsa_recover(data->ctx, &pubkey, &sig, data->msg));
- CHECK(secp256k1_ec_pubkey_serialize(data->ctx, pubkeyc, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED));
- for (j = 0; j < 32; j++) {
- data->sig[j + 32] = data->msg[j]; /* Move former message to S. */
- data->msg[j] = data->sig[j]; /* Move former R to message. */
- data->sig[j] = pubkeyc[j + 1]; /* Move recovered pubkey X coordinate to R (which must be a valid X coordinate). */
- }
- }
-}
-
-void bench_recover_setup(void* arg) {
- int i;
- bench_recover_t *data = (bench_recover_t*)arg;
-
- for (i = 0; i < 32; i++) {
- data->msg[i] = 1 + i;
- }
- for (i = 0; i < 64; i++) {
- data->sig[i] = 65 + i;
- }
-}
-
-int main(void) {
- bench_recover_t data;
-
- data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);
-
- run_benchmark("ecdsa_recover", bench_recover, bench_recover_setup, NULL, &data, 10, 20000);
-
- secp256k1_context_destroy(data.ctx);
- return 0;
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_schnorr_verify.c op-geth/crypto/secp256k1/libsecp256k1/src/bench_schnorr_verify.c
deleted file mode 100644
index 5f137dda23ef3a62326a6aee21cd152fa09860da..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_schnorr_verify.c
+++ /dev/null
@@ -1,73 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#include <stdio.h>
-#include <string.h>
-
-#include "include/secp256k1.h"
-#include "include/secp256k1_schnorr.h"
-#include "util.h"
-#include "bench.h"
-
-typedef struct {
- unsigned char key[32];
- unsigned char sig[64];
- unsigned char pubkey[33];
- size_t pubkeylen;
-} benchmark_schnorr_sig_t;
-
-typedef struct {
- secp256k1_context *ctx;
- unsigned char msg[32];
- benchmark_schnorr_sig_t sigs[64];
- int numsigs;
-} benchmark_schnorr_verify_t;
-
-static void benchmark_schnorr_init(void* arg) {
- int i, k;
- benchmark_schnorr_verify_t* data = (benchmark_schnorr_verify_t*)arg;
-
- for (i = 0; i < 32; i++) {
- data->msg[i] = 1 + i;
- }
- for (k = 0; k < data->numsigs; k++) {
- secp256k1_pubkey pubkey;
- for (i = 0; i < 32; i++) {
- data->sigs[k].key[i] = 33 + i + k;
- }
- secp256k1_schnorr_sign(data->ctx, data->sigs[k].sig, data->msg, data->sigs[k].key, NULL, NULL);
- data->sigs[k].pubkeylen = 33;
- CHECK(secp256k1_ec_pubkey_create(data->ctx, &pubkey, data->sigs[k].key));
- CHECK(secp256k1_ec_pubkey_serialize(data->ctx, data->sigs[k].pubkey, &data->sigs[k].pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED));
- }
-}
-
-static void benchmark_schnorr_verify(void* arg) {
- int i;
- benchmark_schnorr_verify_t* data = (benchmark_schnorr_verify_t*)arg;
-
- for (i = 0; i < 20000 / data->numsigs; i++) {
- secp256k1_pubkey pubkey;
- data->sigs[0].sig[(i >> 8) % 64] ^= (i & 0xFF);
- CHECK(secp256k1_ec_pubkey_parse(data->ctx, &pubkey, data->sigs[0].pubkey, data->sigs[0].pubkeylen));
- CHECK(secp256k1_schnorr_verify(data->ctx, data->sigs[0].sig, data->msg, &pubkey) == ((i & 0xFF) == 0));
- data->sigs[0].sig[(i >> 8) % 64] ^= (i & 0xFF);
- }
-}
-
-
-
-int main(void) {
- benchmark_schnorr_verify_t data;
-
- data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
-
- data.numsigs = 1;
- run_benchmark("schnorr_verify", benchmark_schnorr_verify, benchmark_schnorr_init, NULL, &data, 10, 20000);
-
- secp256k1_context_destroy(data.ctx);
- return 0;
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_sign.c op-geth/crypto/secp256k1/libsecp256k1/src/bench_sign.c
deleted file mode 100644
index ed7224d757e417cb324a3b2e15f0f3268fe68d3a..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_sign.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#include "include/secp256k1.h"
-#include "util.h"
-#include "bench.h"
-
-typedef struct {
- secp256k1_context* ctx;
- unsigned char msg[32];
- unsigned char key[32];
-} bench_sign_t;
-
-static void bench_sign_setup(void* arg) {
- int i;
- bench_sign_t *data = (bench_sign_t*)arg;
-
- for (i = 0; i < 32; i++) {
- data->msg[i] = i + 1;
- }
- for (i = 0; i < 32; i++) {
- data->key[i] = i + 65;
- }
-}
-
-static void bench_sign(void* arg) {
- int i;
- bench_sign_t *data = (bench_sign_t*)arg;
-
- unsigned char sig[74];
- for (i = 0; i < 20000; i++) {
- size_t siglen = 74;
- int j;
- secp256k1_ecdsa_signature signature;
- CHECK(secp256k1_ecdsa_sign(data->ctx, &signature, data->msg, data->key, NULL, NULL));
- CHECK(secp256k1_ecdsa_signature_serialize_der(data->ctx, sig, &siglen, &signature));
- for (j = 0; j < 32; j++) {
- data->msg[j] = sig[j];
- data->key[j] = sig[j + 32];
- }
- }
-}
-
-int main(void) {
- bench_sign_t data;
-
- data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
-
- run_benchmark("ecdsa_sign", bench_sign, bench_sign_setup, NULL, &data, 10, 20000);
-
- secp256k1_context_destroy(data.ctx);
- return 0;
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_verify.c op-geth/crypto/secp256k1/libsecp256k1/src/bench_verify.c
deleted file mode 100644
index 418defa0aa22a06dff07d3f1567e205235706976..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/bench_verify.c
+++ /dev/null
@@ -1,112 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#include <stdio.h>
-#include <string.h>
-
-#include "include/secp256k1.h"
-#include "util.h"
-#include "bench.h"
-
-#ifdef ENABLE_OPENSSL_TESTS
-#include <openssl/bn.h>
-#include <openssl/ecdsa.h>
-#include <openssl/obj_mac.h>
-#endif
-
-typedef struct {
- secp256k1_context *ctx;
- unsigned char msg[32];
- unsigned char key[32];
- unsigned char sig[72];
- size_t siglen;
- unsigned char pubkey[33];
- size_t pubkeylen;
-#ifdef ENABLE_OPENSSL_TESTS
- EC_GROUP* ec_group;
-#endif
-} benchmark_verify_t;
-
-static void benchmark_verify(void* arg) {
- int i;
- benchmark_verify_t* data = (benchmark_verify_t*)arg;
-
- for (i = 0; i < 20000; i++) {
- secp256k1_pubkey pubkey;
- secp256k1_ecdsa_signature sig;
- data->sig[data->siglen - 1] ^= (i & 0xFF);
- data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
- data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
- CHECK(secp256k1_ec_pubkey_parse(data->ctx, &pubkey, data->pubkey, data->pubkeylen) == 1);
- CHECK(secp256k1_ecdsa_signature_parse_der(data->ctx, &sig, data->sig, data->siglen) == 1);
- CHECK(secp256k1_ecdsa_verify(data->ctx, &sig, data->msg, &pubkey) == (i == 0));
- data->sig[data->siglen - 1] ^= (i & 0xFF);
- data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
- data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
- }
-}
-
-#ifdef ENABLE_OPENSSL_TESTS
-static void benchmark_verify_openssl(void* arg) {
- int i;
- benchmark_verify_t* data = (benchmark_verify_t*)arg;
-
- for (i = 0; i < 20000; i++) {
- data->sig[data->siglen - 1] ^= (i & 0xFF);
- data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
- data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
- {
- EC_KEY *pkey = EC_KEY_new();
- const unsigned char *pubkey = &data->pubkey[0];
- int result;
-
- CHECK(pkey != NULL);
- result = EC_KEY_set_group(pkey, data->ec_group);
- CHECK(result);
- result = (o2i_ECPublicKey(&pkey, &pubkey, data->pubkeylen)) != NULL;
- CHECK(result);
- result = ECDSA_verify(0, &data->msg[0], sizeof(data->msg), &data->sig[0], data->siglen, pkey) == (i == 0);
- CHECK(result);
- EC_KEY_free(pkey);
- }
- data->sig[data->siglen - 1] ^= (i & 0xFF);
- data->sig[data->siglen - 2] ^= ((i >> 8) & 0xFF);
- data->sig[data->siglen - 3] ^= ((i >> 16) & 0xFF);
- }
-}
-#endif
-
-int main(void) {
- int i;
- secp256k1_pubkey pubkey;
- secp256k1_ecdsa_signature sig;
- benchmark_verify_t data;
-
- data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
-
- for (i = 0; i < 32; i++) {
- data.msg[i] = 1 + i;
- }
- for (i = 0; i < 32; i++) {
- data.key[i] = 33 + i;
- }
- data.siglen = 72;
- CHECK(secp256k1_ecdsa_sign(data.ctx, &sig, data.msg, data.key, NULL, NULL));
- CHECK(secp256k1_ecdsa_signature_serialize_der(data.ctx, data.sig, &data.siglen, &sig));
- CHECK(secp256k1_ec_pubkey_create(data.ctx, &pubkey, data.key));
- data.pubkeylen = 33;
- CHECK(secp256k1_ec_pubkey_serialize(data.ctx, data.pubkey, &data.pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED) == 1);
-
- run_benchmark("ecdsa_verify", benchmark_verify, NULL, NULL, &data, 10, 20000);
-#ifdef ENABLE_OPENSSL_TESTS
- data.ec_group = EC_GROUP_new_by_curve_name(NID_secp256k1);
- run_benchmark("ecdsa_verify_openssl", benchmark_verify_openssl, NULL, NULL, &data, 10, 20000);
- EC_GROUP_free(data.ec_group);
-#endif
-
- secp256k1_context_destroy(data.ctx);
- return 0;
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/dummy.go op-geth/crypto/secp256k1/libsecp256k1/src/dummy.go
deleted file mode 100644
index 2df270adc35e88d710f5a354f4b10bb6291f5110..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/dummy.go
+++ /dev/null
@@ -1,8 +0,0 @@
-//go:build dummy
-// +build dummy
-
-// Package c contains only a C file.
-//
-// This Go file is part of a workaround for `go mod vendor`.
-// Please see the file crypto/secp256k1/dummy.go for more information.
-package src
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/ecdsa.h op-geth/crypto/secp256k1/libsecp256k1/src/ecdsa.h
deleted file mode 100644
index 54ae101b924138552080eb3fd088654ec481f6a3..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/ecdsa.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_ECDSA_
-#define _SECP256K1_ECDSA_
-
-#include <stddef.h>
-
-#include "scalar.h"
-#include "group.h"
-#include "ecmult.h"
-
-static int secp256k1_ecdsa_sig_parse(secp256k1_scalar *r, secp256k1_scalar *s, const unsigned char *sig, size_t size);
-static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, size_t *size, const secp256k1_scalar *r, const secp256k1_scalar *s);
-static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context *ctx, const secp256k1_scalar* r, const secp256k1_scalar* s, const secp256k1_ge *pubkey, const secp256k1_scalar *message);
-static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context *ctx, secp256k1_scalar* r, secp256k1_scalar* s, const secp256k1_scalar *seckey, const secp256k1_scalar *message, const secp256k1_scalar *nonce, int *recid);
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/ecdsa_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/ecdsa_impl.h
deleted file mode 100644
index 453bb1188066f90f7b4648ac19c8e78212973e11..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/ecdsa_impl.h
+++ /dev/null
@@ -1,315 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013-2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-
-#ifndef _SECP256K1_ECDSA_IMPL_H_
-#define _SECP256K1_ECDSA_IMPL_H_
-
-#include "scalar.h"
-#include "field.h"
-#include "group.h"
-#include "ecmult.h"
-#include "ecmult_gen.h"
-#include "ecdsa.h"
-
-/** Group order for secp256k1 defined as 'n' in "Standards for Efficient Cryptography" (SEC2) 2.7.1
- * sage: for t in xrange(1023, -1, -1):
- * .. p = 2**256 - 2**32 - t
- * .. if p.is_prime():
- * .. print '%x'%p
- * .. break
- * 'fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'
- * sage: a = 0
- * sage: b = 7
- * sage: F = FiniteField (p)
- * sage: '%x' % (EllipticCurve ([F (a), F (b)]).order())
- * 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'
- */
-static const secp256k1_fe secp256k1_ecdsa_const_order_as_fe = SECP256K1_FE_CONST(
- 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL,
- 0xBAAEDCE6UL, 0xAF48A03BUL, 0xBFD25E8CUL, 0xD0364141UL
-);
-
-/** Difference between field and order, values 'p' and 'n' values defined in
- * "Standards for Efficient Cryptography" (SEC2) 2.7.1.
- * sage: p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
- * sage: a = 0
- * sage: b = 7
- * sage: F = FiniteField (p)
- * sage: '%x' % (p - EllipticCurve ([F (a), F (b)]).order())
- * '14551231950b75fc4402da1722fc9baee'
- */
-static const secp256k1_fe secp256k1_ecdsa_const_p_minus_order = SECP256K1_FE_CONST(
- 0, 0, 0, 1, 0x45512319UL, 0x50B75FC4UL, 0x402DA172UL, 0x2FC9BAEEUL
-);
-
-static int secp256k1_der_read_len(const unsigned char **sigp, const unsigned char *sigend) {
- int lenleft, b1;
- size_t ret = 0;
- if (*sigp >= sigend) {
- return -1;
- }
- b1 = *((*sigp)++);
- if (b1 == 0xFF) {
- /* X.690-0207 8.1.3.5.c the value 0xFF shall not be used. */
- return -1;
- }
- if ((b1 & 0x80) == 0) {
- /* X.690-0207 8.1.3.4 short form length octets */
- return b1;
- }
- if (b1 == 0x80) {
- /* Indefinite length is not allowed in DER. */
- return -1;
- }
- /* X.690-207 8.1.3.5 long form length octets */
- lenleft = b1 & 0x7F;
- if (lenleft > sigend - *sigp) {
- return -1;
- }
- if (**sigp == 0) {
- /* Not the shortest possible length encoding. */
- return -1;
- }
- if ((size_t)lenleft > sizeof(size_t)) {
- /* The resulting length would exceed the range of a size_t, so
- * certainly longer than the passed array size.
- */
- return -1;
- }
- while (lenleft > 0) {
- if ((ret >> ((sizeof(size_t) - 1) * 8)) != 0) {
- }
- ret = (ret << 8) | **sigp;
- if (ret + lenleft > (size_t)(sigend - *sigp)) {
- /* Result exceeds the length of the passed array. */
- return -1;
- }
- (*sigp)++;
- lenleft--;
- }
- if (ret < 128) {
- /* Not the shortest possible length encoding. */
- return -1;
- }
- return ret;
-}
-
-static int secp256k1_der_parse_integer(secp256k1_scalar *r, const unsigned char **sig, const unsigned char *sigend) {
- int overflow = 0;
- unsigned char ra[32] = {0};
- int rlen;
-
- if (*sig == sigend || **sig != 0x02) {
- /* Not a primitive integer (X.690-0207 8.3.1). */
- return 0;
- }
- (*sig)++;
- rlen = secp256k1_der_read_len(sig, sigend);
- if (rlen <= 0 || (*sig) + rlen > sigend) {
- /* Exceeds bounds or not at least length 1 (X.690-0207 8.3.1). */
- return 0;
- }
- if (**sig == 0x00 && rlen > 1 && (((*sig)[1]) & 0x80) == 0x00) {
- /* Excessive 0x00 padding. */
- return 0;
- }
- if (**sig == 0xFF && rlen > 1 && (((*sig)[1]) & 0x80) == 0x80) {
- /* Excessive 0xFF padding. */
- return 0;
- }
- if ((**sig & 0x80) == 0x80) {
- /* Negative. */
- overflow = 1;
- }
- while (rlen > 0 && **sig == 0) {
- /* Skip leading zero bytes */
- rlen--;
- (*sig)++;
- }
- if (rlen > 32) {
- overflow = 1;
- }
- if (!overflow) {
- memcpy(ra + 32 - rlen, *sig, rlen);
- secp256k1_scalar_set_b32(r, ra, &overflow);
- }
- if (overflow) {
- secp256k1_scalar_set_int(r, 0);
- }
- (*sig) += rlen;
- return 1;
-}
-
-static int secp256k1_ecdsa_sig_parse(secp256k1_scalar *rr, secp256k1_scalar *rs, const unsigned char *sig, size_t size) {
- const unsigned char *sigend = sig + size;
- int rlen;
- if (sig == sigend || *(sig++) != 0x30) {
- /* The encoding doesn't start with a constructed sequence (X.690-0207 8.9.1). */
- return 0;
- }
- rlen = secp256k1_der_read_len(&sig, sigend);
- if (rlen < 0 || sig + rlen > sigend) {
- /* Tuple exceeds bounds */
- return 0;
- }
- if (sig + rlen != sigend) {
- /* Garbage after tuple. */
- return 0;
- }
-
- if (!secp256k1_der_parse_integer(rr, &sig, sigend)) {
- return 0;
- }
- if (!secp256k1_der_parse_integer(rs, &sig, sigend)) {
- return 0;
- }
-
- if (sig != sigend) {
- /* Trailing garbage inside tuple. */
- return 0;
- }
-
- return 1;
-}
-
-static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, size_t *size, const secp256k1_scalar* ar, const secp256k1_scalar* as) {
- unsigned char r[33] = {0}, s[33] = {0};
- unsigned char *rp = r, *sp = s;
- size_t lenR = 33, lenS = 33;
- secp256k1_scalar_get_b32(&r[1], ar);
- secp256k1_scalar_get_b32(&s[1], as);
- while (lenR > 1 && rp[0] == 0 && rp[1] < 0x80) { lenR--; rp++; }
- while (lenS > 1 && sp[0] == 0 && sp[1] < 0x80) { lenS--; sp++; }
- if (*size < 6+lenS+lenR) {
- *size = 6 + lenS + lenR;
- return 0;
- }
- *size = 6 + lenS + lenR;
- sig[0] = 0x30;
- sig[1] = 4 + lenS + lenR;
- sig[2] = 0x02;
- sig[3] = lenR;
- memcpy(sig+4, rp, lenR);
- sig[4+lenR] = 0x02;
- sig[5+lenR] = lenS;
- memcpy(sig+lenR+6, sp, lenS);
- return 1;
-}
-
-static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context *ctx, const secp256k1_scalar *sigr, const secp256k1_scalar *sigs, const secp256k1_ge *pubkey, const secp256k1_scalar *message) {
- unsigned char c[32];
- secp256k1_scalar sn, u1, u2;
-#if !defined(EXHAUSTIVE_TEST_ORDER)
- secp256k1_fe xr;
-#endif
- secp256k1_gej pubkeyj;
- secp256k1_gej pr;
-
- if (secp256k1_scalar_is_zero(sigr) || secp256k1_scalar_is_zero(sigs)) {
- return 0;
- }
-
- secp256k1_scalar_inverse_var(&sn, sigs);
- secp256k1_scalar_mul(&u1, &sn, message);
- secp256k1_scalar_mul(&u2, &sn, sigr);
- secp256k1_gej_set_ge(&pubkeyj, pubkey);
- secp256k1_ecmult(ctx, &pr, &pubkeyj, &u2, &u1);
- if (secp256k1_gej_is_infinity(&pr)) {
- return 0;
- }
-
-#if defined(EXHAUSTIVE_TEST_ORDER)
-{
- secp256k1_scalar computed_r;
- secp256k1_ge pr_ge;
- secp256k1_ge_set_gej(&pr_ge, &pr);
- secp256k1_fe_normalize(&pr_ge.x);
-
- secp256k1_fe_get_b32(c, &pr_ge.x);
- secp256k1_scalar_set_b32(&computed_r, c, NULL);
- return secp256k1_scalar_eq(sigr, &computed_r);
-}
-#else
- secp256k1_scalar_get_b32(c, sigr);
- secp256k1_fe_set_b32(&xr, c);
-
- /** We now have the recomputed R point in pr, and its claimed x coordinate (modulo n)
- * in xr. Naively, we would extract the x coordinate from pr (requiring a inversion modulo p),
- * compute the remainder modulo n, and compare it to xr. However:
- *
- * xr == X(pr) mod n
- * <=> exists h. (xr + h * n < p && xr + h * n == X(pr))
- * [Since 2 * n > p, h can only be 0 or 1]
- * <=> (xr == X(pr)) || (xr + n < p && xr + n == X(pr))
- * [In Jacobian coordinates, X(pr) is pr.x / pr.z^2 mod p]
- * <=> (xr == pr.x / pr.z^2 mod p) || (xr + n < p && xr + n == pr.x / pr.z^2 mod p)
- * [Multiplying both sides of the equations by pr.z^2 mod p]
- * <=> (xr * pr.z^2 mod p == pr.x) || (xr + n < p && (xr + n) * pr.z^2 mod p == pr.x)
- *
- * Thus, we can avoid the inversion, but we have to check both cases separately.
- * secp256k1_gej_eq_x implements the (xr * pr.z^2 mod p == pr.x) test.
- */
- if (secp256k1_gej_eq_x_var(&xr, &pr)) {
- /* xr * pr.z^2 mod p == pr.x, so the signature is valid. */
- return 1;
- }
- if (secp256k1_fe_cmp_var(&xr, &secp256k1_ecdsa_const_p_minus_order) >= 0) {
- /* xr + n >= p, so we can skip testing the second case. */
- return 0;
- }
- secp256k1_fe_add(&xr, &secp256k1_ecdsa_const_order_as_fe);
- if (secp256k1_gej_eq_x_var(&xr, &pr)) {
- /* (xr + n) * pr.z^2 mod p == pr.x, so the signature is valid. */
- return 1;
- }
- return 0;
-#endif
-}
-
-static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context *ctx, secp256k1_scalar *sigr, secp256k1_scalar *sigs, const secp256k1_scalar *seckey, const secp256k1_scalar *message, const secp256k1_scalar *nonce, int *recid) {
- unsigned char b[32];
- secp256k1_gej rp;
- secp256k1_ge r;
- secp256k1_scalar n;
- int overflow = 0;
-
- secp256k1_ecmult_gen(ctx, &rp, nonce);
- secp256k1_ge_set_gej(&r, &rp);
- secp256k1_fe_normalize(&r.x);
- secp256k1_fe_normalize(&r.y);
- secp256k1_fe_get_b32(b, &r.x);
- secp256k1_scalar_set_b32(sigr, b, &overflow);
- /* These two conditions should be checked before calling */
- VERIFY_CHECK(!secp256k1_scalar_is_zero(sigr));
- VERIFY_CHECK(overflow == 0);
-
- if (recid) {
- /* The overflow condition is cryptographically unreachable as hitting it requires finding the discrete log
- * of some P where P.x >= order, and only 1 in about 2^127 points meet this criteria.
- */
- *recid = (overflow ? 2 : 0) | (secp256k1_fe_is_odd(&r.y) ? 1 : 0);
- }
- secp256k1_scalar_mul(&n, sigr, seckey);
- secp256k1_scalar_add(&n, &n, message);
- secp256k1_scalar_inverse(sigs, nonce);
- secp256k1_scalar_mul(sigs, sigs, &n);
- secp256k1_scalar_clear(&n);
- secp256k1_gej_clear(&rp);
- secp256k1_ge_clear(&r);
- if (secp256k1_scalar_is_zero(sigs)) {
- return 0;
- }
- if (secp256k1_scalar_is_high(sigs)) {
- secp256k1_scalar_negate(sigs, sigs);
- if (recid) {
- *recid ^= 1;
- }
- }
- return 1;
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/eckey.h op-geth/crypto/secp256k1/libsecp256k1/src/eckey.h
deleted file mode 100644
index 42739a3bea7c08abfbefb6e744a5ad904993ce18..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/eckey.h
+++ /dev/null
@@ -1,25 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_ECKEY_
-#define _SECP256K1_ECKEY_
-
-#include <stddef.h>
-
-#include "group.h"
-#include "scalar.h"
-#include "ecmult.h"
-#include "ecmult_gen.h"
-
-static int secp256k1_eckey_pubkey_parse(secp256k1_ge *elem, const unsigned char *pub, size_t size);
-static int secp256k1_eckey_pubkey_serialize(secp256k1_ge *elem, unsigned char *pub, size_t *size, int compressed);
-
-static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar *key, const secp256k1_scalar *tweak);
-static int secp256k1_eckey_pubkey_tweak_add(const secp256k1_ecmult_context *ctx, secp256k1_ge *key, const secp256k1_scalar *tweak);
-static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar *key, const secp256k1_scalar *tweak);
-static int secp256k1_eckey_pubkey_tweak_mul(const secp256k1_ecmult_context *ctx, secp256k1_ge *key, const secp256k1_scalar *tweak);
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/eckey_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/eckey_impl.h
deleted file mode 100644
index ce38071ac2e599dbb70255ec3b8dbf9deadc5fa0..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/eckey_impl.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_ECKEY_IMPL_H_
-#define _SECP256K1_ECKEY_IMPL_H_
-
-#include "eckey.h"
-
-#include "scalar.h"
-#include "field.h"
-#include "group.h"
-#include "ecmult_gen.h"
-
-static int secp256k1_eckey_pubkey_parse(secp256k1_ge *elem, const unsigned char *pub, size_t size) {
- if (size == 33 && (pub[0] == 0x02 || pub[0] == 0x03)) {
- secp256k1_fe x;
- return secp256k1_fe_set_b32(&x, pub+1) && secp256k1_ge_set_xo_var(elem, &x, pub[0] == 0x03);
- } else if (size == 65 && (pub[0] == 0x04 || pub[0] == 0x06 || pub[0] == 0x07)) {
- secp256k1_fe x, y;
- if (!secp256k1_fe_set_b32(&x, pub+1) || !secp256k1_fe_set_b32(&y, pub+33)) {
- return 0;
- }
- secp256k1_ge_set_xy(elem, &x, &y);
- if ((pub[0] == 0x06 || pub[0] == 0x07) && secp256k1_fe_is_odd(&y) != (pub[0] == 0x07)) {
- return 0;
- }
- return secp256k1_ge_is_valid_var(elem);
- } else {
- return 0;
- }
-}
-
-static int secp256k1_eckey_pubkey_serialize(secp256k1_ge *elem, unsigned char *pub, size_t *size, int compressed) {
- if (secp256k1_ge_is_infinity(elem)) {
- return 0;
- }
- secp256k1_fe_normalize_var(&elem->x);
- secp256k1_fe_normalize_var(&elem->y);
- secp256k1_fe_get_b32(&pub[1], &elem->x);
- if (compressed) {
- *size = 33;
- pub[0] = 0x02 | (secp256k1_fe_is_odd(&elem->y) ? 0x01 : 0x00);
- } else {
- *size = 65;
- pub[0] = 0x04;
- secp256k1_fe_get_b32(&pub[33], &elem->y);
- }
- return 1;
-}
-
-static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar *key, const secp256k1_scalar *tweak) {
- secp256k1_scalar_add(key, key, tweak);
- if (secp256k1_scalar_is_zero(key)) {
- return 0;
- }
- return 1;
-}
-
-static int secp256k1_eckey_pubkey_tweak_add(const secp256k1_ecmult_context *ctx, secp256k1_ge *key, const secp256k1_scalar *tweak) {
- secp256k1_gej pt;
- secp256k1_scalar one;
- secp256k1_gej_set_ge(&pt, key);
- secp256k1_scalar_set_int(&one, 1);
- secp256k1_ecmult(ctx, &pt, &pt, &one, tweak);
-
- if (secp256k1_gej_is_infinity(&pt)) {
- return 0;
- }
- secp256k1_ge_set_gej(key, &pt);
- return 1;
-}
-
-static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar *key, const secp256k1_scalar *tweak) {
- if (secp256k1_scalar_is_zero(tweak)) {
- return 0;
- }
-
- secp256k1_scalar_mul(key, key, tweak);
- return 1;
-}
-
-static int secp256k1_eckey_pubkey_tweak_mul(const secp256k1_ecmult_context *ctx, secp256k1_ge *key, const secp256k1_scalar *tweak) {
- secp256k1_scalar zero;
- secp256k1_gej pt;
- if (secp256k1_scalar_is_zero(tweak)) {
- return 0;
- }
-
- secp256k1_scalar_set_int(&zero, 0);
- secp256k1_gej_set_ge(&pt, key);
- secp256k1_ecmult(ctx, &pt, &pt, tweak, &zero);
- secp256k1_ge_set_gej(key, &pt);
- return 1;
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult.h op-geth/crypto/secp256k1/libsecp256k1/src/ecmult.h
deleted file mode 100644
index 20484134f5241402357e99dc119bd5b921d1a478..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_ECMULT_
-#define _SECP256K1_ECMULT_
-
-#include "num.h"
-#include "group.h"
-
-typedef struct {
- /* For accelerating the computation of a*P + b*G: */
- secp256k1_ge_storage (*pre_g)[]; /* odd multiples of the generator */
-#ifdef USE_ENDOMORPHISM
- secp256k1_ge_storage (*pre_g_128)[]; /* odd multiples of 2^128*generator */
-#endif
-} secp256k1_ecmult_context;
-
-static void secp256k1_ecmult_context_init(secp256k1_ecmult_context *ctx);
-static void secp256k1_ecmult_context_build(secp256k1_ecmult_context *ctx, const secp256k1_callback *cb);
-static void secp256k1_ecmult_context_clone(secp256k1_ecmult_context *dst,
- const secp256k1_ecmult_context *src, const secp256k1_callback *cb);
-static void secp256k1_ecmult_context_clear(secp256k1_ecmult_context *ctx);
-static int secp256k1_ecmult_context_is_built(const secp256k1_ecmult_context *ctx);
-
-/** Double multiply: R = na*A + ng*G */
-static void secp256k1_ecmult(const secp256k1_ecmult_context *ctx, secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_scalar *na, const secp256k1_scalar *ng);
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult_const.h op-geth/crypto/secp256k1/libsecp256k1/src/ecmult_const.h
deleted file mode 100644
index 2b0097655c1945393546aeef3c3b4d52c862b771..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult_const.h
+++ /dev/null
@@ -1,15 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_ECMULT_CONST_
-#define _SECP256K1_ECMULT_CONST_
-
-#include "scalar.h"
-#include "group.h"
-
-static void secp256k1_ecmult_const(secp256k1_gej *r, const secp256k1_ge *a, const secp256k1_scalar *q);
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult_const_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/ecmult_const_impl.h
deleted file mode 100644
index 0db314c48e0cdc844a89cb4a6d5b4ce4c9352578..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult_const_impl.h
+++ /dev/null
@@ -1,239 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Pieter Wuille, Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_ECMULT_CONST_IMPL_
-#define _SECP256K1_ECMULT_CONST_IMPL_
-
-#include "scalar.h"
-#include "group.h"
-#include "ecmult_const.h"
-#include "ecmult_impl.h"
-
-#ifdef USE_ENDOMORPHISM
- #define WNAF_BITS 128
-#else
- #define WNAF_BITS 256
-#endif
-#define WNAF_SIZE(w) ((WNAF_BITS + (w) - 1) / (w))
-
-/* This is like `ECMULT_TABLE_GET_GE` but is constant time */
-#define ECMULT_CONST_TABLE_GET_GE(r,pre,n,w) do { \
- int m; \
- int abs_n = (n) * (((n) > 0) * 2 - 1); \
- int idx_n = abs_n / 2; \
- secp256k1_fe neg_y; \
- VERIFY_CHECK(((n) & 1) == 1); \
- VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
- VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); \
- VERIFY_SETUP(secp256k1_fe_clear(&(r)->x)); \
- VERIFY_SETUP(secp256k1_fe_clear(&(r)->y)); \
- for (m = 0; m < ECMULT_TABLE_SIZE(w); m++) { \
- /* This loop is used to avoid secret data in array indices. See
- * the comment in ecmult_gen_impl.h for rationale. */ \
- secp256k1_fe_cmov(&(r)->x, &(pre)[m].x, m == idx_n); \
- secp256k1_fe_cmov(&(r)->y, &(pre)[m].y, m == idx_n); \
- } \
- (r)->infinity = 0; \
- secp256k1_fe_negate(&neg_y, &(r)->y, 1); \
- secp256k1_fe_cmov(&(r)->y, &neg_y, (n) != abs_n); \
-} while(0)
-
-
-/** Convert a number to WNAF notation. The number becomes represented by sum(2^{wi} * wnaf[i], i=0..return_val)
- * with the following guarantees:
- * - each wnaf[i] an odd integer between -(1 << w) and (1 << w)
- * - each wnaf[i] is nonzero
- * - the number of words set is returned; this is always (WNAF_BITS + w - 1) / w
- *
- * Adapted from `The Width-w NAF Method Provides Small Memory and Fast Elliptic Scalar
- * Multiplications Secure against Side Channel Attacks`, Okeya and Tagaki. M. Joye (Ed.)
- * CT-RSA 2003, LNCS 2612, pp. 328-443, 2003. Springer-Verlagy Berlin Heidelberg 2003
- *
- * Numbers reference steps of `Algorithm SPA-resistant Width-w NAF with Odd Scalar` on pp. 335
- */
-static int secp256k1_wnaf_const(int *wnaf, secp256k1_scalar s, int w) {
- int global_sign;
- int skew = 0;
- int word = 0;
-
- /* 1 2 3 */
- int u_last;
- int u;
-
- int flip;
- int bit;
- secp256k1_scalar neg_s;
- int not_neg_one;
- /* Note that we cannot handle even numbers by negating them to be odd, as is
- * done in other implementations, since if our scalars were specified to have
- * width < 256 for performance reasons, their negations would have width 256
- * and we'd lose any performance benefit. Instead, we use a technique from
- * Section 4.2 of the Okeya/Tagaki paper, which is to add either 1 (for even)
- * or 2 (for odd) to the number we are encoding, returning a skew value indicating
- * this, and having the caller compensate after doing the multiplication. */
-
- /* Negative numbers will be negated to keep their bit representation below the maximum width */
- flip = secp256k1_scalar_is_high(&s);
- /* We add 1 to even numbers, 2 to odd ones, noting that negation flips parity */
- bit = flip ^ !secp256k1_scalar_is_even(&s);
- /* We check for negative one, since adding 2 to it will cause an overflow */
- secp256k1_scalar_negate(&neg_s, &s);
- not_neg_one = !secp256k1_scalar_is_one(&neg_s);
- secp256k1_scalar_cadd_bit(&s, bit, not_neg_one);
- /* If we had negative one, flip == 1, s.d[0] == 0, bit == 1, so caller expects
- * that we added two to it and flipped it. In fact for -1 these operations are
- * identical. We only flipped, but since skewing is required (in the sense that
- * the skew must be 1 or 2, never zero) and flipping is not, we need to change
- * our flags to claim that we only skewed. */
- global_sign = secp256k1_scalar_cond_negate(&s, flip);
- global_sign *= not_neg_one * 2 - 1;
- skew = 1 << bit;
-
- /* 4 */
- u_last = secp256k1_scalar_shr_int(&s, w);
- while (word * w < WNAF_BITS) {
- int sign;
- int even;
-
- /* 4.1 4.4 */
- u = secp256k1_scalar_shr_int(&s, w);
- /* 4.2 */
- even = ((u & 1) == 0);
- sign = 2 * (u_last > 0) - 1;
- u += sign * even;
- u_last -= sign * even * (1 << w);
-
- /* 4.3, adapted for global sign change */
- wnaf[word++] = u_last * global_sign;
-
- u_last = u;
- }
- wnaf[word] = u * global_sign;
-
- VERIFY_CHECK(secp256k1_scalar_is_zero(&s));
- VERIFY_CHECK(word == WNAF_SIZE(w));
- return skew;
-}
-
-
-static void secp256k1_ecmult_const(secp256k1_gej *r, const secp256k1_ge *a, const secp256k1_scalar *scalar) {
- secp256k1_ge pre_a[ECMULT_TABLE_SIZE(WINDOW_A)];
- secp256k1_ge tmpa;
- secp256k1_fe Z;
-
- int skew_1;
- int wnaf_1[1 + WNAF_SIZE(WINDOW_A - 1)];
-#ifdef USE_ENDOMORPHISM
- secp256k1_ge pre_a_lam[ECMULT_TABLE_SIZE(WINDOW_A)];
- int wnaf_lam[1 + WNAF_SIZE(WINDOW_A - 1)];
- int skew_lam;
- secp256k1_scalar q_1, q_lam;
-#endif
-
- int i;
- secp256k1_scalar sc = *scalar;
-
- /* build wnaf representation for q. */
-#ifdef USE_ENDOMORPHISM
- /* split q into q_1 and q_lam (where q = q_1 + q_lam*lambda, and q_1 and q_lam are ~128 bit) */
- secp256k1_scalar_split_lambda(&q_1, &q_lam, &sc);
- skew_1 = secp256k1_wnaf_const(wnaf_1, q_1, WINDOW_A - 1);
- skew_lam = secp256k1_wnaf_const(wnaf_lam, q_lam, WINDOW_A - 1);
-#else
- skew_1 = secp256k1_wnaf_const(wnaf_1, sc, WINDOW_A - 1);
-#endif
-
- /* Calculate odd multiples of a.
- * All multiples are brought to the same Z 'denominator', which is stored
- * in Z. Due to secp256k1' isomorphism we can do all operations pretending
- * that the Z coordinate was 1, use affine addition formulae, and correct
- * the Z coordinate of the result once at the end.
- */
- secp256k1_gej_set_ge(r, a);
- secp256k1_ecmult_odd_multiples_table_globalz_windowa(pre_a, &Z, r);
- for (i = 0; i < ECMULT_TABLE_SIZE(WINDOW_A); i++) {
- secp256k1_fe_normalize_weak(&pre_a[i].y);
- }
-#ifdef USE_ENDOMORPHISM
- for (i = 0; i < ECMULT_TABLE_SIZE(WINDOW_A); i++) {
- secp256k1_ge_mul_lambda(&pre_a_lam[i], &pre_a[i]);
- }
-#endif
-
- /* first loop iteration (separated out so we can directly set r, rather
- * than having it start at infinity, get doubled several times, then have
- * its new value added to it) */
- i = wnaf_1[WNAF_SIZE(WINDOW_A - 1)];
- VERIFY_CHECK(i != 0);
- ECMULT_CONST_TABLE_GET_GE(&tmpa, pre_a, i, WINDOW_A);
- secp256k1_gej_set_ge(r, &tmpa);
-#ifdef USE_ENDOMORPHISM
- i = wnaf_lam[WNAF_SIZE(WINDOW_A - 1)];
- VERIFY_CHECK(i != 0);
- ECMULT_CONST_TABLE_GET_GE(&tmpa, pre_a_lam, i, WINDOW_A);
- secp256k1_gej_add_ge(r, r, &tmpa);
-#endif
- /* remaining loop iterations */
- for (i = WNAF_SIZE(WINDOW_A - 1) - 1; i >= 0; i--) {
- int n;
- int j;
- for (j = 0; j < WINDOW_A - 1; ++j) {
- secp256k1_gej_double_nonzero(r, r, NULL);
- }
-
- n = wnaf_1[i];
- ECMULT_CONST_TABLE_GET_GE(&tmpa, pre_a, n, WINDOW_A);
- VERIFY_CHECK(n != 0);
- secp256k1_gej_add_ge(r, r, &tmpa);
-#ifdef USE_ENDOMORPHISM
- n = wnaf_lam[i];
- ECMULT_CONST_TABLE_GET_GE(&tmpa, pre_a_lam, n, WINDOW_A);
- VERIFY_CHECK(n != 0);
- secp256k1_gej_add_ge(r, r, &tmpa);
-#endif
- }
-
- secp256k1_fe_mul(&r->z, &r->z, &Z);
-
- {
- /* Correct for wNAF skew */
- secp256k1_ge correction = *a;
- secp256k1_ge_storage correction_1_stor;
-#ifdef USE_ENDOMORPHISM
- secp256k1_ge_storage correction_lam_stor;
-#endif
- secp256k1_ge_storage a2_stor;
- secp256k1_gej tmpj;
- secp256k1_gej_set_ge(&tmpj, &correction);
- secp256k1_gej_double_var(&tmpj, &tmpj, NULL);
- secp256k1_ge_set_gej(&correction, &tmpj);
- secp256k1_ge_to_storage(&correction_1_stor, a);
-#ifdef USE_ENDOMORPHISM
- secp256k1_ge_to_storage(&correction_lam_stor, a);
-#endif
- secp256k1_ge_to_storage(&a2_stor, &correction);
-
- /* For odd numbers this is 2a (so replace it), for even ones a (so no-op) */
- secp256k1_ge_storage_cmov(&correction_1_stor, &a2_stor, skew_1 == 2);
-#ifdef USE_ENDOMORPHISM
- secp256k1_ge_storage_cmov(&correction_lam_stor, &a2_stor, skew_lam == 2);
-#endif
-
- /* Apply the correction */
- secp256k1_ge_from_storage(&correction, &correction_1_stor);
- secp256k1_ge_neg(&correction, &correction);
- secp256k1_gej_add_ge(r, r, &correction);
-
-#ifdef USE_ENDOMORPHISM
- secp256k1_ge_from_storage(&correction, &correction_lam_stor);
- secp256k1_ge_neg(&correction, &correction);
- secp256k1_ge_mul_lambda(&correction, &correction);
- secp256k1_gej_add_ge(r, r, &correction);
-#endif
- }
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult_gen.h op-geth/crypto/secp256k1/libsecp256k1/src/ecmult_gen.h
deleted file mode 100644
index eb2cc9ead6ed1df81b34bb5a579d0c61f991fd38..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult_gen.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_ECMULT_GEN_
-#define _SECP256K1_ECMULT_GEN_
-
-#include "scalar.h"
-#include "group.h"
-
-typedef struct {
- /* For accelerating the computation of a*G:
- * To harden against timing attacks, use the following mechanism:
- * * Break up the multiplicand into groups of 4 bits, called n_0, n_1, n_2, ..., n_63.
- * * Compute sum(n_i * 16^i * G + U_i, i=0..63), where:
- * * U_i = U * 2^i (for i=0..62)
- * * U_i = U * (1-2^63) (for i=63)
- * where U is a point with no known corresponding scalar. Note that sum(U_i, i=0..63) = 0.
- * For each i, and each of the 16 possible values of n_i, (n_i * 16^i * G + U_i) is
- * precomputed (call it prec(i, n_i)). The formula now becomes sum(prec(i, n_i), i=0..63).
- * None of the resulting prec group elements have a known scalar, and neither do any of
- * the intermediate sums while computing a*G.
- */
- secp256k1_ge_storage (*prec)[64][16]; /* prec[j][i] = 16^j * i * G + U_i */
- secp256k1_scalar blind;
- secp256k1_gej initial;
-} secp256k1_ecmult_gen_context;
-
-static void secp256k1_ecmult_gen_context_init(secp256k1_ecmult_gen_context* ctx);
-static void secp256k1_ecmult_gen_context_build(secp256k1_ecmult_gen_context* ctx, const secp256k1_callback* cb);
-static void secp256k1_ecmult_gen_context_clone(secp256k1_ecmult_gen_context *dst,
- const secp256k1_ecmult_gen_context* src, const secp256k1_callback* cb);
-static void secp256k1_ecmult_gen_context_clear(secp256k1_ecmult_gen_context* ctx);
-static int secp256k1_ecmult_gen_context_is_built(const secp256k1_ecmult_gen_context* ctx);
-
-/** Multiply with the generator: R = a*G */
-static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context* ctx, secp256k1_gej *r, const secp256k1_scalar *a);
-
-static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx, const unsigned char *seed32);
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult_gen_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/ecmult_gen_impl.h
deleted file mode 100644
index 35f25460773f3ab1819beb6a1633ef264c83408d..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult_gen_impl.h
+++ /dev/null
@@ -1,210 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014, 2015 Pieter Wuille, Gregory Maxwell *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_ECMULT_GEN_IMPL_H_
-#define _SECP256K1_ECMULT_GEN_IMPL_H_
-
-#include "scalar.h"
-#include "group.h"
-#include "ecmult_gen.h"
-#include "hash_impl.h"
-#ifdef USE_ECMULT_STATIC_PRECOMPUTATION
-#include "ecmult_static_context.h"
-#endif
-static void secp256k1_ecmult_gen_context_init(secp256k1_ecmult_gen_context *ctx) {
- ctx->prec = NULL;
-}
-
-static void secp256k1_ecmult_gen_context_build(secp256k1_ecmult_gen_context *ctx, const secp256k1_callback* cb) {
-#ifndef USE_ECMULT_STATIC_PRECOMPUTATION
- secp256k1_ge prec[1024];
- secp256k1_gej gj;
- secp256k1_gej nums_gej;
- int i, j;
-#endif
-
- if (ctx->prec != NULL) {
- return;
- }
-#ifndef USE_ECMULT_STATIC_PRECOMPUTATION
- ctx->prec = (secp256k1_ge_storage (*)[64][16])checked_malloc(cb, sizeof(*ctx->prec));
-
- /* get the generator */
- secp256k1_gej_set_ge(&gj, &secp256k1_ge_const_g);
-
- /* Construct a group element with no known corresponding scalar (nothing up my sleeve). */
- {
- static const unsigned char nums_b32[33] = "The scalar for this x is unknown";
- secp256k1_fe nums_x;
- secp256k1_ge nums_ge;
- int r;
- r = secp256k1_fe_set_b32(&nums_x, nums_b32);
- (void)r;
- VERIFY_CHECK(r);
- r = secp256k1_ge_set_xo_var(&nums_ge, &nums_x, 0);
- (void)r;
- VERIFY_CHECK(r);
- secp256k1_gej_set_ge(&nums_gej, &nums_ge);
- /* Add G to make the bits in x uniformly distributed. */
- secp256k1_gej_add_ge_var(&nums_gej, &nums_gej, &secp256k1_ge_const_g, NULL);
- }
-
- /* compute prec. */
- {
- secp256k1_gej precj[1024]; /* Jacobian versions of prec. */
- secp256k1_gej gbase;
- secp256k1_gej numsbase;
- gbase = gj; /* 16^j * G */
- numsbase = nums_gej; /* 2^j * nums. */
- for (j = 0; j < 64; j++) {
- /* Set precj[j*16 .. j*16+15] to (numsbase, numsbase + gbase, ..., numsbase + 15*gbase). */
- precj[j*16] = numsbase;
- for (i = 1; i < 16; i++) {
- secp256k1_gej_add_var(&precj[j*16 + i], &precj[j*16 + i - 1], &gbase, NULL);
- }
- /* Multiply gbase by 16. */
- for (i = 0; i < 4; i++) {
- secp256k1_gej_double_var(&gbase, &gbase, NULL);
- }
- /* Multiply numbase by 2. */
- secp256k1_gej_double_var(&numsbase, &numsbase, NULL);
- if (j == 62) {
- /* In the last iteration, numsbase is (1 - 2^j) * nums instead. */
- secp256k1_gej_neg(&numsbase, &numsbase);
- secp256k1_gej_add_var(&numsbase, &numsbase, &nums_gej, NULL);
- }
- }
- secp256k1_ge_set_all_gej_var(prec, precj, 1024, cb);
- }
- for (j = 0; j < 64; j++) {
- for (i = 0; i < 16; i++) {
- secp256k1_ge_to_storage(&(*ctx->prec)[j][i], &prec[j*16 + i]);
- }
- }
-#else
- (void)cb;
- ctx->prec = (secp256k1_ge_storage (*)[64][16])secp256k1_ecmult_static_context;
-#endif
- secp256k1_ecmult_gen_blind(ctx, NULL);
-}
-
-static int secp256k1_ecmult_gen_context_is_built(const secp256k1_ecmult_gen_context* ctx) {
- return ctx->prec != NULL;
-}
-
-static void secp256k1_ecmult_gen_context_clone(secp256k1_ecmult_gen_context *dst,
- const secp256k1_ecmult_gen_context *src, const secp256k1_callback* cb) {
- if (src->prec == NULL) {
- dst->prec = NULL;
- } else {
-#ifndef USE_ECMULT_STATIC_PRECOMPUTATION
- dst->prec = (secp256k1_ge_storage (*)[64][16])checked_malloc(cb, sizeof(*dst->prec));
- memcpy(dst->prec, src->prec, sizeof(*dst->prec));
-#else
- (void)cb;
- dst->prec = src->prec;
-#endif
- dst->initial = src->initial;
- dst->blind = src->blind;
- }
-}
-
-static void secp256k1_ecmult_gen_context_clear(secp256k1_ecmult_gen_context *ctx) {
-#ifndef USE_ECMULT_STATIC_PRECOMPUTATION
- free(ctx->prec);
-#endif
- secp256k1_scalar_clear(&ctx->blind);
- secp256k1_gej_clear(&ctx->initial);
- ctx->prec = NULL;
-}
-
-static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context *ctx, secp256k1_gej *r, const secp256k1_scalar *gn) {
- secp256k1_ge add;
- secp256k1_ge_storage adds;
- secp256k1_scalar gnb;
- int bits;
- int i, j;
- memset(&adds, 0, sizeof(adds));
- *r = ctx->initial;
- /* Blind scalar/point multiplication by computing (n-b)G + bG instead of nG. */
- secp256k1_scalar_add(&gnb, gn, &ctx->blind);
- add.infinity = 0;
- for (j = 0; j < 64; j++) {
- bits = secp256k1_scalar_get_bits(&gnb, j * 4, 4);
- for (i = 0; i < 16; i++) {
- /** This uses a conditional move to avoid any secret data in array indexes.
- * _Any_ use of secret indexes has been demonstrated to result in timing
- * sidechannels, even when the cache-line access patterns are uniform.
- * See also:
- * "A word of warning", CHES 2013 Rump Session, by Daniel J. Bernstein and Peter Schwabe
- * (https://cryptojedi.org/peter/data/chesrump-20130822.pdf) and
- * "Cache Attacks and Countermeasures: the Case of AES", RSA 2006,
- * by Dag Arne Osvik, Adi Shamir, and Eran Tromer
- * (http://www.tau.ac.il/~tromer/papers/cache.pdf)
- */
- secp256k1_ge_storage_cmov(&adds, &(*ctx->prec)[j][i], i == bits);
- }
- secp256k1_ge_from_storage(&add, &adds);
- secp256k1_gej_add_ge(r, r, &add);
- }
- bits = 0;
- secp256k1_ge_clear(&add);
- secp256k1_scalar_clear(&gnb);
-}
-
-/* Setup blinding values for secp256k1_ecmult_gen. */
-static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx, const unsigned char *seed32) {
- secp256k1_scalar b;
- secp256k1_gej gb;
- secp256k1_fe s;
- unsigned char nonce32[32];
- secp256k1_rfc6979_hmac_sha256_t rng;
- int retry;
- unsigned char keydata[64] = {0};
- if (seed32 == NULL) {
- /* When seed is NULL, reset the initial point and blinding value. */
- secp256k1_gej_set_ge(&ctx->initial, &secp256k1_ge_const_g);
- secp256k1_gej_neg(&ctx->initial, &ctx->initial);
- secp256k1_scalar_set_int(&ctx->blind, 1);
- }
- /* The prior blinding value (if not reset) is chained forward by including it in the hash. */
- secp256k1_scalar_get_b32(nonce32, &ctx->blind);
- /** Using a CSPRNG allows a failure free interface, avoids needing large amounts of random data,
- * and guards against weak or adversarial seeds. This is a simpler and safer interface than
- * asking the caller for blinding values directly and expecting them to retry on failure.
- */
- memcpy(keydata, nonce32, 32);
- if (seed32 != NULL) {
- memcpy(keydata + 32, seed32, 32);
- }
- secp256k1_rfc6979_hmac_sha256_initialize(&rng, keydata, seed32 ? 64 : 32);
- memset(keydata, 0, sizeof(keydata));
- /* Retry for out of range results to achieve uniformity. */
- do {
- secp256k1_rfc6979_hmac_sha256_generate(&rng, nonce32, 32);
- retry = !secp256k1_fe_set_b32(&s, nonce32);
- retry |= secp256k1_fe_is_zero(&s);
- } while (retry); /* This branch true is cryptographically unreachable. Requires sha256_hmac output > Fp. */
- /* Randomize the projection to defend against multiplier sidechannels. */
- secp256k1_gej_rescale(&ctx->initial, &s);
- secp256k1_fe_clear(&s);
- do {
- secp256k1_rfc6979_hmac_sha256_generate(&rng, nonce32, 32);
- secp256k1_scalar_set_b32(&b, nonce32, &retry);
- /* A blinding value of 0 works, but would undermine the projection hardening. */
- retry |= secp256k1_scalar_is_zero(&b);
- } while (retry); /* This branch true is cryptographically unreachable. Requires sha256_hmac output > order. */
- secp256k1_rfc6979_hmac_sha256_finalize(&rng);
- memset(nonce32, 0, 32);
- secp256k1_ecmult_gen(ctx, &gb, &b);
- secp256k1_scalar_negate(&b, &b);
- ctx->blind = b;
- ctx->initial = gb;
- secp256k1_scalar_clear(&b);
- secp256k1_gej_clear(&gb);
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/ecmult_impl.h
deleted file mode 100644
index 4e40104ad43ceb12845b79994c5bd5d28f3b31a0..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/ecmult_impl.h
+++ /dev/null
@@ -1,406 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_ECMULT_IMPL_H_
-#define _SECP256K1_ECMULT_IMPL_H_
-
-#include <string.h>
-
-#include "group.h"
-#include "scalar.h"
-#include "ecmult.h"
-
-#if defined(EXHAUSTIVE_TEST_ORDER)
-/* We need to lower these values for exhaustive tests because
- * the tables cannot have infinities in them (this breaks the
- * affine-isomorphism stuff which tracks z-ratios) */
-# if EXHAUSTIVE_TEST_ORDER > 128
-# define WINDOW_A 5
-# define WINDOW_G 8
-# elif EXHAUSTIVE_TEST_ORDER > 8
-# define WINDOW_A 4
-# define WINDOW_G 4
-# else
-# define WINDOW_A 2
-# define WINDOW_G 2
-# endif
-#else
-/* optimal for 128-bit and 256-bit exponents. */
-#define WINDOW_A 5
-/** larger numbers may result in slightly better performance, at the cost of
- exponentially larger precomputed tables. */
-#ifdef USE_ENDOMORPHISM
-/** Two tables for window size 15: 1.375 MiB. */
-#define WINDOW_G 15
-#else
-/** One table for window size 16: 1.375 MiB. */
-#define WINDOW_G 16
-#endif
-#endif
-
-/** The number of entries a table with precomputed multiples needs to have. */
-#define ECMULT_TABLE_SIZE(w) (1 << ((w)-2))
-
-/** Fill a table 'prej' with precomputed odd multiples of a. Prej will contain
- * the values [1*a,3*a,...,(2*n-1)*a], so it space for n values. zr[0] will
- * contain prej[0].z / a.z. The other zr[i] values = prej[i].z / prej[i-1].z.
- * Prej's Z values are undefined, except for the last value.
- */
-static void secp256k1_ecmult_odd_multiples_table(int n, secp256k1_gej *prej, secp256k1_fe *zr, const secp256k1_gej *a) {
- secp256k1_gej d;
- secp256k1_ge a_ge, d_ge;
- int i;
-
- VERIFY_CHECK(!a->infinity);
-
- secp256k1_gej_double_var(&d, a, NULL);
-
- /*
- * Perform the additions on an isomorphism where 'd' is affine: drop the z coordinate
- * of 'd', and scale the 1P starting value's x/y coordinates without changing its z.
- */
- d_ge.x = d.x;
- d_ge.y = d.y;
- d_ge.infinity = 0;
-
- secp256k1_ge_set_gej_zinv(&a_ge, a, &d.z);
- prej[0].x = a_ge.x;
- prej[0].y = a_ge.y;
- prej[0].z = a->z;
- prej[0].infinity = 0;
-
- zr[0] = d.z;
- for (i = 1; i < n; i++) {
- secp256k1_gej_add_ge_var(&prej[i], &prej[i-1], &d_ge, &zr[i]);
- }
-
- /*
- * Each point in 'prej' has a z coordinate too small by a factor of 'd.z'. Only
- * the final point's z coordinate is actually used though, so just update that.
- */
- secp256k1_fe_mul(&prej[n-1].z, &prej[n-1].z, &d.z);
-}
-
-/** Fill a table 'pre' with precomputed odd multiples of a.
- *
- * There are two versions of this function:
- * - secp256k1_ecmult_odd_multiples_table_globalz_windowa which brings its
- * resulting point set to a single constant Z denominator, stores the X and Y
- * coordinates as ge_storage points in pre, and stores the global Z in rz.
- * It only operates on tables sized for WINDOW_A wnaf multiples.
- * - secp256k1_ecmult_odd_multiples_table_storage_var, which converts its
- * resulting point set to actually affine points, and stores those in pre.
- * It operates on tables of any size, but uses heap-allocated temporaries.
- *
- * To compute a*P + b*G, we compute a table for P using the first function,
- * and for G using the second (which requires an inverse, but it only needs to
- * happen once).
- */
-static void secp256k1_ecmult_odd_multiples_table_globalz_windowa(secp256k1_ge *pre, secp256k1_fe *globalz, const secp256k1_gej *a) {
- secp256k1_gej prej[ECMULT_TABLE_SIZE(WINDOW_A)];
- secp256k1_fe zr[ECMULT_TABLE_SIZE(WINDOW_A)];
-
- /* Compute the odd multiples in Jacobian form. */
- secp256k1_ecmult_odd_multiples_table(ECMULT_TABLE_SIZE(WINDOW_A), prej, zr, a);
- /* Bring them to the same Z denominator. */
- secp256k1_ge_globalz_set_table_gej(ECMULT_TABLE_SIZE(WINDOW_A), pre, globalz, prej, zr);
-}
-
-static void secp256k1_ecmult_odd_multiples_table_storage_var(int n, secp256k1_ge_storage *pre, const secp256k1_gej *a, const secp256k1_callback *cb) {
- secp256k1_gej *prej = (secp256k1_gej*)checked_malloc(cb, sizeof(secp256k1_gej) * n);
- secp256k1_ge *prea = (secp256k1_ge*)checked_malloc(cb, sizeof(secp256k1_ge) * n);
- secp256k1_fe *zr = (secp256k1_fe*)checked_malloc(cb, sizeof(secp256k1_fe) * n);
- int i;
-
- /* Compute the odd multiples in Jacobian form. */
- secp256k1_ecmult_odd_multiples_table(n, prej, zr, a);
- /* Convert them in batch to affine coordinates. */
- secp256k1_ge_set_table_gej_var(prea, prej, zr, n);
- /* Convert them to compact storage form. */
- for (i = 0; i < n; i++) {
- secp256k1_ge_to_storage(&pre[i], &prea[i]);
- }
-
- free(prea);
- free(prej);
- free(zr);
-}
-
-/** The following two macro retrieves a particular odd multiple from a table
- * of precomputed multiples. */
-#define ECMULT_TABLE_GET_GE(r,pre,n,w) do { \
- VERIFY_CHECK(((n) & 1) == 1); \
- VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
- VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); \
- if ((n) > 0) { \
- *(r) = (pre)[((n)-1)/2]; \
- } else { \
- secp256k1_ge_neg((r), &(pre)[(-(n)-1)/2]); \
- } \
-} while(0)
-
-#define ECMULT_TABLE_GET_GE_STORAGE(r,pre,n,w) do { \
- VERIFY_CHECK(((n) & 1) == 1); \
- VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
- VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); \
- if ((n) > 0) { \
- secp256k1_ge_from_storage((r), &(pre)[((n)-1)/2]); \
- } else { \
- secp256k1_ge_from_storage((r), &(pre)[(-(n)-1)/2]); \
- secp256k1_ge_neg((r), (r)); \
- } \
-} while(0)
-
-static void secp256k1_ecmult_context_init(secp256k1_ecmult_context *ctx) {
- ctx->pre_g = NULL;
-#ifdef USE_ENDOMORPHISM
- ctx->pre_g_128 = NULL;
-#endif
-}
-
-static void secp256k1_ecmult_context_build(secp256k1_ecmult_context *ctx, const secp256k1_callback *cb) {
- secp256k1_gej gj;
-
- if (ctx->pre_g != NULL) {
- return;
- }
-
- /* get the generator */
- secp256k1_gej_set_ge(&gj, &secp256k1_ge_const_g);
-
- ctx->pre_g = (secp256k1_ge_storage (*)[])checked_malloc(cb, sizeof((*ctx->pre_g)[0]) * ECMULT_TABLE_SIZE(WINDOW_G));
-
- /* precompute the tables with odd multiples */
- secp256k1_ecmult_odd_multiples_table_storage_var(ECMULT_TABLE_SIZE(WINDOW_G), *ctx->pre_g, &gj, cb);
-
-#ifdef USE_ENDOMORPHISM
- {
- secp256k1_gej g_128j;
- int i;
-
- ctx->pre_g_128 = (secp256k1_ge_storage (*)[])checked_malloc(cb, sizeof((*ctx->pre_g_128)[0]) * ECMULT_TABLE_SIZE(WINDOW_G));
-
- /* calculate 2^128*generator */
- g_128j = gj;
- for (i = 0; i < 128; i++) {
- secp256k1_gej_double_var(&g_128j, &g_128j, NULL);
- }
- secp256k1_ecmult_odd_multiples_table_storage_var(ECMULT_TABLE_SIZE(WINDOW_G), *ctx->pre_g_128, &g_128j, cb);
- }
-#endif
-}
-
-static void secp256k1_ecmult_context_clone(secp256k1_ecmult_context *dst,
- const secp256k1_ecmult_context *src, const secp256k1_callback *cb) {
- if (src->pre_g == NULL) {
- dst->pre_g = NULL;
- } else {
- size_t size = sizeof((*dst->pre_g)[0]) * ECMULT_TABLE_SIZE(WINDOW_G);
- dst->pre_g = (secp256k1_ge_storage (*)[])checked_malloc(cb, size);
- memcpy(dst->pre_g, src->pre_g, size);
- }
-#ifdef USE_ENDOMORPHISM
- if (src->pre_g_128 == NULL) {
- dst->pre_g_128 = NULL;
- } else {
- size_t size = sizeof((*dst->pre_g_128)[0]) * ECMULT_TABLE_SIZE(WINDOW_G);
- dst->pre_g_128 = (secp256k1_ge_storage (*)[])checked_malloc(cb, size);
- memcpy(dst->pre_g_128, src->pre_g_128, size);
- }
-#endif
-}
-
-static int secp256k1_ecmult_context_is_built(const secp256k1_ecmult_context *ctx) {
- return ctx->pre_g != NULL;
-}
-
-static void secp256k1_ecmult_context_clear(secp256k1_ecmult_context *ctx) {
- free(ctx->pre_g);
-#ifdef USE_ENDOMORPHISM
- free(ctx->pre_g_128);
-#endif
- secp256k1_ecmult_context_init(ctx);
-}
-
-/** Convert a number to WNAF notation. The number becomes represented by sum(2^i * wnaf[i], i=0..bits),
- * with the following guarantees:
- * - each wnaf[i] is either 0, or an odd integer between -(1<<(w-1) - 1) and (1<<(w-1) - 1)
- * - two non-zero entries in wnaf are separated by at least w-1 zeroes.
- * - the number of set values in wnaf is returned. This number is at most 256, and at most one more
- * than the number of bits in the (absolute value) of the input.
- */
-static int secp256k1_ecmult_wnaf(int *wnaf, int len, const secp256k1_scalar *a, int w) {
- secp256k1_scalar s = *a;
- int last_set_bit = -1;
- int bit = 0;
- int sign = 1;
- int carry = 0;
-
- VERIFY_CHECK(wnaf != NULL);
- VERIFY_CHECK(0 <= len && len <= 256);
- VERIFY_CHECK(a != NULL);
- VERIFY_CHECK(2 <= w && w <= 31);
-
- memset(wnaf, 0, len * sizeof(wnaf[0]));
-
- if (secp256k1_scalar_get_bits(&s, 255, 1)) {
- secp256k1_scalar_negate(&s, &s);
- sign = -1;
- }
-
- while (bit < len) {
- int now;
- int word;
- if (secp256k1_scalar_get_bits(&s, bit, 1) == (unsigned int)carry) {
- bit++;
- continue;
- }
-
- now = w;
- if (now > len - bit) {
- now = len - bit;
- }
-
- word = secp256k1_scalar_get_bits_var(&s, bit, now) + carry;
-
- carry = (word >> (w-1)) & 1;
- word -= carry << w;
-
- wnaf[bit] = sign * word;
- last_set_bit = bit;
-
- bit += now;
- }
-#ifdef VERIFY
- CHECK(carry == 0);
- while (bit < 256) {
- CHECK(secp256k1_scalar_get_bits(&s, bit++, 1) == 0);
- }
-#endif
- return last_set_bit + 1;
-}
-
-static void secp256k1_ecmult(const secp256k1_ecmult_context *ctx, secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_scalar *na, const secp256k1_scalar *ng) {
- secp256k1_ge pre_a[ECMULT_TABLE_SIZE(WINDOW_A)];
- secp256k1_ge tmpa;
- secp256k1_fe Z;
-#ifdef USE_ENDOMORPHISM
- secp256k1_ge pre_a_lam[ECMULT_TABLE_SIZE(WINDOW_A)];
- secp256k1_scalar na_1, na_lam;
- /* Splitted G factors. */
- secp256k1_scalar ng_1, ng_128;
- int wnaf_na_1[130];
- int wnaf_na_lam[130];
- int bits_na_1;
- int bits_na_lam;
- int wnaf_ng_1[129];
- int bits_ng_1;
- int wnaf_ng_128[129];
- int bits_ng_128;
-#else
- int wnaf_na[256];
- int bits_na;
- int wnaf_ng[256];
- int bits_ng;
-#endif
- int i;
- int bits;
-
-#ifdef USE_ENDOMORPHISM
- /* split na into na_1 and na_lam (where na = na_1 + na_lam*lambda, and na_1 and na_lam are ~128 bit) */
- secp256k1_scalar_split_lambda(&na_1, &na_lam, na);
-
- /* build wnaf representation for na_1 and na_lam. */
- bits_na_1 = secp256k1_ecmult_wnaf(wnaf_na_1, 130, &na_1, WINDOW_A);
- bits_na_lam = secp256k1_ecmult_wnaf(wnaf_na_lam, 130, &na_lam, WINDOW_A);
- VERIFY_CHECK(bits_na_1 <= 130);
- VERIFY_CHECK(bits_na_lam <= 130);
- bits = bits_na_1;
- if (bits_na_lam > bits) {
- bits = bits_na_lam;
- }
-#else
- /* build wnaf representation for na. */
- bits_na = secp256k1_ecmult_wnaf(wnaf_na, 256, na, WINDOW_A);
- bits = bits_na;
-#endif
-
- /* Calculate odd multiples of a.
- * All multiples are brought to the same Z 'denominator', which is stored
- * in Z. Due to secp256k1' isomorphism we can do all operations pretending
- * that the Z coordinate was 1, use affine addition formulae, and correct
- * the Z coordinate of the result once at the end.
- * The exception is the precomputed G table points, which are actually
- * affine. Compared to the base used for other points, they have a Z ratio
- * of 1/Z, so we can use secp256k1_gej_add_zinv_var, which uses the same
- * isomorphism to efficiently add with a known Z inverse.
- */
- secp256k1_ecmult_odd_multiples_table_globalz_windowa(pre_a, &Z, a);
-
-#ifdef USE_ENDOMORPHISM
- for (i = 0; i < ECMULT_TABLE_SIZE(WINDOW_A); i++) {
- secp256k1_ge_mul_lambda(&pre_a_lam[i], &pre_a[i]);
- }
-
- /* split ng into ng_1 and ng_128 (where gn = gn_1 + gn_128*2^128, and gn_1 and gn_128 are ~128 bit) */
- secp256k1_scalar_split_128(&ng_1, &ng_128, ng);
-
- /* Build wnaf representation for ng_1 and ng_128 */
- bits_ng_1 = secp256k1_ecmult_wnaf(wnaf_ng_1, 129, &ng_1, WINDOW_G);
- bits_ng_128 = secp256k1_ecmult_wnaf(wnaf_ng_128, 129, &ng_128, WINDOW_G);
- if (bits_ng_1 > bits) {
- bits = bits_ng_1;
- }
- if (bits_ng_128 > bits) {
- bits = bits_ng_128;
- }
-#else
- bits_ng = secp256k1_ecmult_wnaf(wnaf_ng, 256, ng, WINDOW_G);
- if (bits_ng > bits) {
- bits = bits_ng;
- }
-#endif
-
- secp256k1_gej_set_infinity(r);
-
- for (i = bits - 1; i >= 0; i--) {
- int n;
- secp256k1_gej_double_var(r, r, NULL);
-#ifdef USE_ENDOMORPHISM
- if (i < bits_na_1 && (n = wnaf_na_1[i])) {
- ECMULT_TABLE_GET_GE(&tmpa, pre_a, n, WINDOW_A);
- secp256k1_gej_add_ge_var(r, r, &tmpa, NULL);
- }
- if (i < bits_na_lam && (n = wnaf_na_lam[i])) {
- ECMULT_TABLE_GET_GE(&tmpa, pre_a_lam, n, WINDOW_A);
- secp256k1_gej_add_ge_var(r, r, &tmpa, NULL);
- }
- if (i < bits_ng_1 && (n = wnaf_ng_1[i])) {
- ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g, n, WINDOW_G);
- secp256k1_gej_add_zinv_var(r, r, &tmpa, &Z);
- }
- if (i < bits_ng_128 && (n = wnaf_ng_128[i])) {
- ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g_128, n, WINDOW_G);
- secp256k1_gej_add_zinv_var(r, r, &tmpa, &Z);
- }
-#else
- if (i < bits_na && (n = wnaf_na[i])) {
- ECMULT_TABLE_GET_GE(&tmpa, pre_a, n, WINDOW_A);
- secp256k1_gej_add_ge_var(r, r, &tmpa, NULL);
- }
- if (i < bits_ng && (n = wnaf_ng[i])) {
- ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g, n, WINDOW_G);
- secp256k1_gej_add_zinv_var(r, r, &tmpa, &Z);
- }
-#endif
- }
-
- if (!r->infinity) {
- secp256k1_fe_mul(&r->z, &r->z, &Z);
- }
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/field.h op-geth/crypto/secp256k1/libsecp256k1/src/field.h
deleted file mode 100644
index bbb1ee866cc427108f03a4f94fc1da27981c29fa..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/field.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_FIELD_
-#define _SECP256K1_FIELD_
-
-/** Field element module.
- *
- * Field elements can be represented in several ways, but code accessing
- * it (and implementations) need to take certain properties into account:
- * - Each field element can be normalized or not.
- * - Each field element has a magnitude, which represents how far away
- * its representation is away from normalization. Normalized elements
- * always have a magnitude of 1, but a magnitude of 1 doesn't imply
- * normality.
- */
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#if defined(USE_FIELD_10X26)
-#include "field_10x26.h"
-#elif defined(USE_FIELD_5X52)
-#include "field_5x52.h"
-#else
-#error "Please select field implementation"
-#endif
-
-#include "util.h"
-
-/** Normalize a field element. */
-static void secp256k1_fe_normalize(secp256k1_fe *r);
-
-/** Weakly normalize a field element: reduce it magnitude to 1, but don't fully normalize. */
-static void secp256k1_fe_normalize_weak(secp256k1_fe *r);
-
-/** Normalize a field element, without constant-time guarantee. */
-static void secp256k1_fe_normalize_var(secp256k1_fe *r);
-
-/** Verify whether a field element represents zero i.e. would normalize to a zero value. The field
- * implementation may optionally normalize the input, but this should not be relied upon. */
-static int secp256k1_fe_normalizes_to_zero(secp256k1_fe *r);
-
-/** Verify whether a field element represents zero i.e. would normalize to a zero value. The field
- * implementation may optionally normalize the input, but this should not be relied upon. */
-static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe *r);
-
-/** Set a field element equal to a small integer. Resulting field element is normalized. */
-static void secp256k1_fe_set_int(secp256k1_fe *r, int a);
-
-/** Sets a field element equal to zero, initializing all fields. */
-static void secp256k1_fe_clear(secp256k1_fe *a);
-
-/** Verify whether a field element is zero. Requires the input to be normalized. */
-static int secp256k1_fe_is_zero(const secp256k1_fe *a);
-
-/** Check the "oddness" of a field element. Requires the input to be normalized. */
-static int secp256k1_fe_is_odd(const secp256k1_fe *a);
-
-/** Compare two field elements. Requires magnitude-1 inputs. */
-static int secp256k1_fe_equal(const secp256k1_fe *a, const secp256k1_fe *b);
-
-/** Same as secp256k1_fe_equal, but may be variable time. */
-static int secp256k1_fe_equal_var(const secp256k1_fe *a, const secp256k1_fe *b);
-
-/** Compare two field elements. Requires both inputs to be normalized */
-static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_fe *b);
-
-/** Set a field element equal to 32-byte big endian value. If successful, the resulting field element is normalized. */
-static int secp256k1_fe_set_b32(secp256k1_fe *r, const unsigned char *a);
-
-/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
-static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a);
-
-/** Set a field element equal to the additive inverse of another. Takes a maximum magnitude of the input
- * as an argument. The magnitude of the output is one higher. */
-static void secp256k1_fe_negate(secp256k1_fe *r, const secp256k1_fe *a, int m);
-
-/** Multiplies the passed field element with a small integer constant. Multiplies the magnitude by that
- * small integer. */
-static void secp256k1_fe_mul_int(secp256k1_fe *r, int a);
-
-/** Adds a field element to another. The result has the sum of the inputs' magnitudes as magnitude. */
-static void secp256k1_fe_add(secp256k1_fe *r, const secp256k1_fe *a);
-
-/** Sets a field element to be the product of two others. Requires the inputs' magnitudes to be at most 8.
- * The output magnitude is 1 (but not guaranteed to be normalized). */
-static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b);
-
-/** Sets a field element to be the square of another. Requires the input's magnitude to be at most 8.
- * The output magnitude is 1 (but not guaranteed to be normalized). */
-static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a);
-
-/** If a has a square root, it is computed in r and 1 is returned. If a does not
- * have a square root, the root of its negation is computed and 0 is returned.
- * The input's magnitude can be at most 8. The output magnitude is 1 (but not
- * guaranteed to be normalized). The result in r will always be a square
- * itself. */
-static int secp256k1_fe_sqrt(secp256k1_fe *r, const secp256k1_fe *a);
-
-/** Checks whether a field element is a quadratic residue. */
-static int secp256k1_fe_is_quad_var(const secp256k1_fe *a);
-
-/** Sets a field element to be the (modular) inverse of another. Requires the input's magnitude to be
- * at most 8. The output magnitude is 1 (but not guaranteed to be normalized). */
-static void secp256k1_fe_inv(secp256k1_fe *r, const secp256k1_fe *a);
-
-/** Potentially faster version of secp256k1_fe_inv, without constant-time guarantee. */
-static void secp256k1_fe_inv_var(secp256k1_fe *r, const secp256k1_fe *a);
-
-/** Calculate the (modular) inverses of a batch of field elements. Requires the inputs' magnitudes to be
- * at most 8. The output magnitudes are 1 (but not guaranteed to be normalized). The inputs and
- * outputs must not overlap in memory. */
-static void secp256k1_fe_inv_all_var(secp256k1_fe *r, const secp256k1_fe *a, size_t len);
-
-/** Convert a field element to the storage type. */
-static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a);
-
-/** Convert a field element back from the storage type. */
-static void secp256k1_fe_from_storage(secp256k1_fe *r, const secp256k1_fe_storage *a);
-
-/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
-static void secp256k1_fe_storage_cmov(secp256k1_fe_storage *r, const secp256k1_fe_storage *a, int flag);
-
-/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
-static void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag);
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/field_10x26.h op-geth/crypto/secp256k1/libsecp256k1/src/field_10x26.h
deleted file mode 100644
index 61ee1e09656442501ef8f16ea96dc48b19ead357..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/field_10x26.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_FIELD_REPR_
-#define _SECP256K1_FIELD_REPR_
-
-#include <stdint.h>
-
-typedef struct {
- /* X = sum(i=0..9, elem[i]*2^26) mod n */
- uint32_t n[10];
-#ifdef VERIFY
- int magnitude;
- int normalized;
-#endif
-} secp256k1_fe;
-
-/* Unpacks a constant into a overlapping multi-limbed FE element. */
-#define SECP256K1_FE_CONST_INNER(d7, d6, d5, d4, d3, d2, d1, d0) { \
- (d0) & 0x3FFFFFFUL, \
- (((uint32_t)d0) >> 26) | (((uint32_t)(d1) & 0xFFFFFUL) << 6), \
- (((uint32_t)d1) >> 20) | (((uint32_t)(d2) & 0x3FFFUL) << 12), \
- (((uint32_t)d2) >> 14) | (((uint32_t)(d3) & 0xFFUL) << 18), \
- (((uint32_t)d3) >> 8) | (((uint32_t)(d4) & 0x3UL) << 24), \
- (((uint32_t)d4) >> 2) & 0x3FFFFFFUL, \
- (((uint32_t)d4) >> 28) | (((uint32_t)(d5) & 0x3FFFFFUL) << 4), \
- (((uint32_t)d5) >> 22) | (((uint32_t)(d6) & 0xFFFFUL) << 10), \
- (((uint32_t)d6) >> 16) | (((uint32_t)(d7) & 0x3FFUL) << 16), \
- (((uint32_t)d7) >> 10) \
-}
-
-#ifdef VERIFY
-#define SECP256K1_FE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {SECP256K1_FE_CONST_INNER((d7), (d6), (d5), (d4), (d3), (d2), (d1), (d0)), 1, 1}
-#else
-#define SECP256K1_FE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {SECP256K1_FE_CONST_INNER((d7), (d6), (d5), (d4), (d3), (d2), (d1), (d0))}
-#endif
-
-typedef struct {
- uint32_t n[8];
-} secp256k1_fe_storage;
-
-#define SECP256K1_FE_STORAGE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{ (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }}
-#define SECP256K1_FE_STORAGE_CONST_GET(d) d.n[7], d.n[6], d.n[5], d.n[4],d.n[3], d.n[2], d.n[1], d.n[0]
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/field_10x26_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/field_10x26_impl.h
deleted file mode 100644
index 5fb092f1beb5cb0d07dcbe180150d14321e9ddba..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/field_10x26_impl.h
+++ /dev/null
@@ -1,1140 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_FIELD_REPR_IMPL_H_
-#define _SECP256K1_FIELD_REPR_IMPL_H_
-
-#include "util.h"
-#include "num.h"
-#include "field.h"
-
-#ifdef VERIFY
-static void secp256k1_fe_verify(const secp256k1_fe *a) {
- const uint32_t *d = a->n;
- int m = a->normalized ? 1 : 2 * a->magnitude, r = 1;
- r &= (d[0] <= 0x3FFFFFFUL * m);
- r &= (d[1] <= 0x3FFFFFFUL * m);
- r &= (d[2] <= 0x3FFFFFFUL * m);
- r &= (d[3] <= 0x3FFFFFFUL * m);
- r &= (d[4] <= 0x3FFFFFFUL * m);
- r &= (d[5] <= 0x3FFFFFFUL * m);
- r &= (d[6] <= 0x3FFFFFFUL * m);
- r &= (d[7] <= 0x3FFFFFFUL * m);
- r &= (d[8] <= 0x3FFFFFFUL * m);
- r &= (d[9] <= 0x03FFFFFUL * m);
- r &= (a->magnitude >= 0);
- r &= (a->magnitude <= 32);
- if (a->normalized) {
- r &= (a->magnitude <= 1);
- if (r && (d[9] == 0x03FFFFFUL)) {
- uint32_t mid = d[8] & d[7] & d[6] & d[5] & d[4] & d[3] & d[2];
- if (mid == 0x3FFFFFFUL) {
- r &= ((d[1] + 0x40UL + ((d[0] + 0x3D1UL) >> 26)) <= 0x3FFFFFFUL);
- }
- }
- }
- VERIFY_CHECK(r == 1);
-}
-#endif
-
-static void secp256k1_fe_normalize(secp256k1_fe *r) {
- uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
- t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
-
- /* Reduce t9 at the start so there will be at most a single carry from the first pass */
- uint32_t m;
- uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
-
- /* The first pass ensures the magnitude is 1, ... */
- t0 += x * 0x3D1UL; t1 += (x << 6);
- t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
- t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
- t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; m = t2;
- t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; m &= t3;
- t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; m &= t4;
- t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; m &= t5;
- t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; m &= t6;
- t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; m &= t7;
- t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; m &= t8;
-
- /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
- VERIFY_CHECK(t9 >> 23 == 0);
-
- /* At most a single final reduction is needed; check if the value is >= the field characteristic */
- x = (t9 >> 22) | ((t9 == 0x03FFFFFUL) & (m == 0x3FFFFFFUL)
- & ((t1 + 0x40UL + ((t0 + 0x3D1UL) >> 26)) > 0x3FFFFFFUL));
-
- /* Apply the final reduction (for constant-time behaviour, we do it always) */
- t0 += x * 0x3D1UL; t1 += (x << 6);
- t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
- t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
- t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL;
- t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL;
- t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL;
- t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL;
- t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL;
- t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL;
- t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL;
-
- /* If t9 didn't carry to bit 22 already, then it should have after any final reduction */
- VERIFY_CHECK(t9 >> 22 == x);
-
- /* Mask off the possible multiple of 2^256 from the final reduction */
- t9 &= 0x03FFFFFUL;
-
- r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
- r->n[5] = t5; r->n[6] = t6; r->n[7] = t7; r->n[8] = t8; r->n[9] = t9;
-
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 1;
- secp256k1_fe_verify(r);
-#endif
-}
-
-static void secp256k1_fe_normalize_weak(secp256k1_fe *r) {
- uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
- t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
-
- /* Reduce t9 at the start so there will be at most a single carry from the first pass */
- uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
-
- /* The first pass ensures the magnitude is 1, ... */
- t0 += x * 0x3D1UL; t1 += (x << 6);
- t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
- t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
- t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL;
- t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL;
- t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL;
- t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL;
- t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL;
- t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL;
- t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL;
-
- /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
- VERIFY_CHECK(t9 >> 23 == 0);
-
- r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
- r->n[5] = t5; r->n[6] = t6; r->n[7] = t7; r->n[8] = t8; r->n[9] = t9;
-
-#ifdef VERIFY
- r->magnitude = 1;
- secp256k1_fe_verify(r);
-#endif
-}
-
-static void secp256k1_fe_normalize_var(secp256k1_fe *r) {
- uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
- t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
-
- /* Reduce t9 at the start so there will be at most a single carry from the first pass */
- uint32_t m;
- uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
-
- /* The first pass ensures the magnitude is 1, ... */
- t0 += x * 0x3D1UL; t1 += (x << 6);
- t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
- t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
- t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; m = t2;
- t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; m &= t3;
- t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; m &= t4;
- t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; m &= t5;
- t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; m &= t6;
- t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; m &= t7;
- t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; m &= t8;
-
- /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
- VERIFY_CHECK(t9 >> 23 == 0);
-
- /* At most a single final reduction is needed; check if the value is >= the field characteristic */
- x = (t9 >> 22) | ((t9 == 0x03FFFFFUL) & (m == 0x3FFFFFFUL)
- & ((t1 + 0x40UL + ((t0 + 0x3D1UL) >> 26)) > 0x3FFFFFFUL));
-
- if (x) {
- t0 += 0x3D1UL; t1 += (x << 6);
- t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
- t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
- t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL;
- t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL;
- t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL;
- t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL;
- t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL;
- t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL;
- t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL;
-
- /* If t9 didn't carry to bit 22 already, then it should have after any final reduction */
- VERIFY_CHECK(t9 >> 22 == x);
-
- /* Mask off the possible multiple of 2^256 from the final reduction */
- t9 &= 0x03FFFFFUL;
- }
-
- r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
- r->n[5] = t5; r->n[6] = t6; r->n[7] = t7; r->n[8] = t8; r->n[9] = t9;
-
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 1;
- secp256k1_fe_verify(r);
-#endif
-}
-
-static int secp256k1_fe_normalizes_to_zero(secp256k1_fe *r) {
- uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
- t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
-
- /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
- uint32_t z0, z1;
-
- /* Reduce t9 at the start so there will be at most a single carry from the first pass */
- uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
-
- /* The first pass ensures the magnitude is 1, ... */
- t0 += x * 0x3D1UL; t1 += (x << 6);
- t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL; z0 = t0; z1 = t0 ^ 0x3D0UL;
- t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL; z0 |= t1; z1 &= t1 ^ 0x40UL;
- t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; z0 |= t2; z1 &= t2;
- t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; z0 |= t3; z1 &= t3;
- t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; z0 |= t4; z1 &= t4;
- t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; z0 |= t5; z1 &= t5;
- t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; z0 |= t6; z1 &= t6;
- t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; z0 |= t7; z1 &= t7;
- t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; z0 |= t8; z1 &= t8;
- z0 |= t9; z1 &= t9 ^ 0x3C00000UL;
-
- /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
- VERIFY_CHECK(t9 >> 23 == 0);
-
- return (z0 == 0) | (z1 == 0x3FFFFFFUL);
-}
-
-static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe *r) {
- uint32_t t0, t1, t2, t3, t4, t5, t6, t7, t8, t9;
- uint32_t z0, z1;
- uint32_t x;
-
- t0 = r->n[0];
- t9 = r->n[9];
-
- /* Reduce t9 at the start so there will be at most a single carry from the first pass */
- x = t9 >> 22;
-
- /* The first pass ensures the magnitude is 1, ... */
- t0 += x * 0x3D1UL;
-
- /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
- z0 = t0 & 0x3FFFFFFUL;
- z1 = z0 ^ 0x3D0UL;
-
- /* Fast return path should catch the majority of cases */
- if ((z0 != 0UL) & (z1 != 0x3FFFFFFUL)) {
- return 0;
- }
-
- t1 = r->n[1];
- t2 = r->n[2];
- t3 = r->n[3];
- t4 = r->n[4];
- t5 = r->n[5];
- t6 = r->n[6];
- t7 = r->n[7];
- t8 = r->n[8];
-
- t9 &= 0x03FFFFFUL;
- t1 += (x << 6);
-
- t1 += (t0 >> 26);
- t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL; z0 |= t1; z1 &= t1 ^ 0x40UL;
- t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; z0 |= t2; z1 &= t2;
- t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; z0 |= t3; z1 &= t3;
- t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; z0 |= t4; z1 &= t4;
- t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; z0 |= t5; z1 &= t5;
- t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; z0 |= t6; z1 &= t6;
- t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; z0 |= t7; z1 &= t7;
- t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; z0 |= t8; z1 &= t8;
- z0 |= t9; z1 &= t9 ^ 0x3C00000UL;
-
- /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
- VERIFY_CHECK(t9 >> 23 == 0);
-
- return (z0 == 0) | (z1 == 0x3FFFFFFUL);
-}
-
-SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe *r, int a) {
- r->n[0] = a;
- r->n[1] = r->n[2] = r->n[3] = r->n[4] = r->n[5] = r->n[6] = r->n[7] = r->n[8] = r->n[9] = 0;
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 1;
- secp256k1_fe_verify(r);
-#endif
-}
-
-SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe *a) {
- const uint32_t *t = a->n;
-#ifdef VERIFY
- VERIFY_CHECK(a->normalized);
- secp256k1_fe_verify(a);
-#endif
- return (t[0] | t[1] | t[2] | t[3] | t[4] | t[5] | t[6] | t[7] | t[8] | t[9]) == 0;
-}
-
-SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe *a) {
-#ifdef VERIFY
- VERIFY_CHECK(a->normalized);
- secp256k1_fe_verify(a);
-#endif
- return a->n[0] & 1;
-}
-
-SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
- int i;
-#ifdef VERIFY
- a->magnitude = 0;
- a->normalized = 1;
-#endif
- for (i=0; i<10; i++) {
- a->n[i] = 0;
- }
-}
-
-static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_fe *b) {
- int i;
-#ifdef VERIFY
- VERIFY_CHECK(a->normalized);
- VERIFY_CHECK(b->normalized);
- secp256k1_fe_verify(a);
- secp256k1_fe_verify(b);
-#endif
- for (i = 9; i >= 0; i--) {
- if (a->n[i] > b->n[i]) {
- return 1;
- }
- if (a->n[i] < b->n[i]) {
- return -1;
- }
- }
- return 0;
-}
-
-static int secp256k1_fe_set_b32(secp256k1_fe *r, const unsigned char *a) {
- int i;
- r->n[0] = r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
- r->n[5] = r->n[6] = r->n[7] = r->n[8] = r->n[9] = 0;
- for (i=0; i<32; i++) {
- int j;
- for (j=0; j<4; j++) {
- int limb = (8*i+2*j)/26;
- int shift = (8*i+2*j)%26;
- r->n[limb] |= (uint32_t)((a[31-i] >> (2*j)) & 0x3) << shift;
- }
- }
- if (r->n[9] == 0x3FFFFFUL && (r->n[8] & r->n[7] & r->n[6] & r->n[5] & r->n[4] & r->n[3] & r->n[2]) == 0x3FFFFFFUL && (r->n[1] + 0x40UL + ((r->n[0] + 0x3D1UL) >> 26)) > 0x3FFFFFFUL) {
- return 0;
- }
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 1;
- secp256k1_fe_verify(r);
-#endif
- return 1;
-}
-
-/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
-static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a) {
- int i;
-#ifdef VERIFY
- VERIFY_CHECK(a->normalized);
- secp256k1_fe_verify(a);
-#endif
- for (i=0; i<32; i++) {
- int j;
- int c = 0;
- for (j=0; j<4; j++) {
- int limb = (8*i+2*j)/26;
- int shift = (8*i+2*j)%26;
- c |= ((a->n[limb] >> shift) & 0x3) << (2 * j);
- }
- r[31-i] = c;
- }
-}
-
-SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe *r, const secp256k1_fe *a, int m) {
-#ifdef VERIFY
- VERIFY_CHECK(a->magnitude <= m);
- secp256k1_fe_verify(a);
-#endif
- r->n[0] = 0x3FFFC2FUL * 2 * (m + 1) - a->n[0];
- r->n[1] = 0x3FFFFBFUL * 2 * (m + 1) - a->n[1];
- r->n[2] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[2];
- r->n[3] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[3];
- r->n[4] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[4];
- r->n[5] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[5];
- r->n[6] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[6];
- r->n[7] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[7];
- r->n[8] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[8];
- r->n[9] = 0x03FFFFFUL * 2 * (m + 1) - a->n[9];
-#ifdef VERIFY
- r->magnitude = m + 1;
- r->normalized = 0;
- secp256k1_fe_verify(r);
-#endif
-}
-
-SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe *r, int a) {
- r->n[0] *= a;
- r->n[1] *= a;
- r->n[2] *= a;
- r->n[3] *= a;
- r->n[4] *= a;
- r->n[5] *= a;
- r->n[6] *= a;
- r->n[7] *= a;
- r->n[8] *= a;
- r->n[9] *= a;
-#ifdef VERIFY
- r->magnitude *= a;
- r->normalized = 0;
- secp256k1_fe_verify(r);
-#endif
-}
-
-SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe *r, const secp256k1_fe *a) {
-#ifdef VERIFY
- secp256k1_fe_verify(a);
-#endif
- r->n[0] += a->n[0];
- r->n[1] += a->n[1];
- r->n[2] += a->n[2];
- r->n[3] += a->n[3];
- r->n[4] += a->n[4];
- r->n[5] += a->n[5];
- r->n[6] += a->n[6];
- r->n[7] += a->n[7];
- r->n[8] += a->n[8];
- r->n[9] += a->n[9];
-#ifdef VERIFY
- r->magnitude += a->magnitude;
- r->normalized = 0;
- secp256k1_fe_verify(r);
-#endif
-}
-
-#if defined(USE_EXTERNAL_ASM)
-
-/* External assembler implementation */
-void secp256k1_fe_mul_inner(uint32_t *r, const uint32_t *a, const uint32_t * SECP256K1_RESTRICT b);
-void secp256k1_fe_sqr_inner(uint32_t *r, const uint32_t *a);
-
-#else
-
-#ifdef VERIFY
-#define VERIFY_BITS(x, n) VERIFY_CHECK(((x) >> (n)) == 0)
-#else
-#define VERIFY_BITS(x, n) do { } while(0)
-#endif
-
-SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint32_t *r, const uint32_t *a, const uint32_t * SECP256K1_RESTRICT b) {
- uint64_t c, d;
- uint64_t u0, u1, u2, u3, u4, u5, u6, u7, u8;
- uint32_t t9, t1, t0, t2, t3, t4, t5, t6, t7;
- const uint32_t M = 0x3FFFFFFUL, R0 = 0x3D10UL, R1 = 0x400UL;
-
- VERIFY_BITS(a[0], 30);
- VERIFY_BITS(a[1], 30);
- VERIFY_BITS(a[2], 30);
- VERIFY_BITS(a[3], 30);
- VERIFY_BITS(a[4], 30);
- VERIFY_BITS(a[5], 30);
- VERIFY_BITS(a[6], 30);
- VERIFY_BITS(a[7], 30);
- VERIFY_BITS(a[8], 30);
- VERIFY_BITS(a[9], 26);
- VERIFY_BITS(b[0], 30);
- VERIFY_BITS(b[1], 30);
- VERIFY_BITS(b[2], 30);
- VERIFY_BITS(b[3], 30);
- VERIFY_BITS(b[4], 30);
- VERIFY_BITS(b[5], 30);
- VERIFY_BITS(b[6], 30);
- VERIFY_BITS(b[7], 30);
- VERIFY_BITS(b[8], 30);
- VERIFY_BITS(b[9], 26);
-
- /** [... a b c] is a shorthand for ... + a<<52 + b<<26 + c<<0 mod n.
- * px is a shorthand for sum(a[i]*b[x-i], i=0..x).
- * Note that [x 0 0 0 0 0 0 0 0 0 0] = [x*R1 x*R0].
- */
-
- d = (uint64_t)a[0] * b[9]
- + (uint64_t)a[1] * b[8]
- + (uint64_t)a[2] * b[7]
- + (uint64_t)a[3] * b[6]
- + (uint64_t)a[4] * b[5]
- + (uint64_t)a[5] * b[4]
- + (uint64_t)a[6] * b[3]
- + (uint64_t)a[7] * b[2]
- + (uint64_t)a[8] * b[1]
- + (uint64_t)a[9] * b[0];
- /* VERIFY_BITS(d, 64); */
- /* [d 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
- t9 = d & M; d >>= 26;
- VERIFY_BITS(t9, 26);
- VERIFY_BITS(d, 38);
- /* [d t9 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
-
- c = (uint64_t)a[0] * b[0];
- VERIFY_BITS(c, 60);
- /* [d t9 0 0 0 0 0 0 0 0 c] = [p9 0 0 0 0 0 0 0 0 p0] */
- d += (uint64_t)a[1] * b[9]
- + (uint64_t)a[2] * b[8]
- + (uint64_t)a[3] * b[7]
- + (uint64_t)a[4] * b[6]
- + (uint64_t)a[5] * b[5]
- + (uint64_t)a[6] * b[4]
- + (uint64_t)a[7] * b[3]
- + (uint64_t)a[8] * b[2]
- + (uint64_t)a[9] * b[1];
- VERIFY_BITS(d, 63);
- /* [d t9 0 0 0 0 0 0 0 0 c] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
- u0 = d & M; d >>= 26; c += u0 * R0;
- VERIFY_BITS(u0, 26);
- VERIFY_BITS(d, 37);
- VERIFY_BITS(c, 61);
- /* [d u0 t9 0 0 0 0 0 0 0 0 c-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
- t0 = c & M; c >>= 26; c += u0 * R1;
- VERIFY_BITS(t0, 26);
- VERIFY_BITS(c, 37);
- /* [d u0 t9 0 0 0 0 0 0 0 c-u0*R1 t0-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
- /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
-
- c += (uint64_t)a[0] * b[1]
- + (uint64_t)a[1] * b[0];
- VERIFY_BITS(c, 62);
- /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 p1 p0] */
- d += (uint64_t)a[2] * b[9]
- + (uint64_t)a[3] * b[8]
- + (uint64_t)a[4] * b[7]
- + (uint64_t)a[5] * b[6]
- + (uint64_t)a[6] * b[5]
- + (uint64_t)a[7] * b[4]
- + (uint64_t)a[8] * b[3]
- + (uint64_t)a[9] * b[2];
- VERIFY_BITS(d, 63);
- /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
- u1 = d & M; d >>= 26; c += u1 * R0;
- VERIFY_BITS(u1, 26);
- VERIFY_BITS(d, 37);
- VERIFY_BITS(c, 63);
- /* [d u1 0 t9 0 0 0 0 0 0 0 c-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
- t1 = c & M; c >>= 26; c += u1 * R1;
- VERIFY_BITS(t1, 26);
- VERIFY_BITS(c, 38);
- /* [d u1 0 t9 0 0 0 0 0 0 c-u1*R1 t1-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
- /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
-
- c += (uint64_t)a[0] * b[2]
- + (uint64_t)a[1] * b[1]
- + (uint64_t)a[2] * b[0];
- VERIFY_BITS(c, 62);
- /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
- d += (uint64_t)a[3] * b[9]
- + (uint64_t)a[4] * b[8]
- + (uint64_t)a[5] * b[7]
- + (uint64_t)a[6] * b[6]
- + (uint64_t)a[7] * b[5]
- + (uint64_t)a[8] * b[4]
- + (uint64_t)a[9] * b[3];
- VERIFY_BITS(d, 63);
- /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
- u2 = d & M; d >>= 26; c += u2 * R0;
- VERIFY_BITS(u2, 26);
- VERIFY_BITS(d, 37);
- VERIFY_BITS(c, 63);
- /* [d u2 0 0 t9 0 0 0 0 0 0 c-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
- t2 = c & M; c >>= 26; c += u2 * R1;
- VERIFY_BITS(t2, 26);
- VERIFY_BITS(c, 38);
- /* [d u2 0 0 t9 0 0 0 0 0 c-u2*R1 t2-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
- /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
-
- c += (uint64_t)a[0] * b[3]
- + (uint64_t)a[1] * b[2]
- + (uint64_t)a[2] * b[1]
- + (uint64_t)a[3] * b[0];
- VERIFY_BITS(c, 63);
- /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
- d += (uint64_t)a[4] * b[9]
- + (uint64_t)a[5] * b[8]
- + (uint64_t)a[6] * b[7]
- + (uint64_t)a[7] * b[6]
- + (uint64_t)a[8] * b[5]
- + (uint64_t)a[9] * b[4];
- VERIFY_BITS(d, 63);
- /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
- u3 = d & M; d >>= 26; c += u3 * R0;
- VERIFY_BITS(u3, 26);
- VERIFY_BITS(d, 37);
- /* VERIFY_BITS(c, 64); */
- /* [d u3 0 0 0 t9 0 0 0 0 0 c-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
- t3 = c & M; c >>= 26; c += u3 * R1;
- VERIFY_BITS(t3, 26);
- VERIFY_BITS(c, 39);
- /* [d u3 0 0 0 t9 0 0 0 0 c-u3*R1 t3-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
- /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
-
- c += (uint64_t)a[0] * b[4]
- + (uint64_t)a[1] * b[3]
- + (uint64_t)a[2] * b[2]
- + (uint64_t)a[3] * b[1]
- + (uint64_t)a[4] * b[0];
- VERIFY_BITS(c, 63);
- /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
- d += (uint64_t)a[5] * b[9]
- + (uint64_t)a[6] * b[8]
- + (uint64_t)a[7] * b[7]
- + (uint64_t)a[8] * b[6]
- + (uint64_t)a[9] * b[5];
- VERIFY_BITS(d, 62);
- /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
- u4 = d & M; d >>= 26; c += u4 * R0;
- VERIFY_BITS(u4, 26);
- VERIFY_BITS(d, 36);
- /* VERIFY_BITS(c, 64); */
- /* [d u4 0 0 0 0 t9 0 0 0 0 c-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
- t4 = c & M; c >>= 26; c += u4 * R1;
- VERIFY_BITS(t4, 26);
- VERIFY_BITS(c, 39);
- /* [d u4 0 0 0 0 t9 0 0 0 c-u4*R1 t4-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
-
- c += (uint64_t)a[0] * b[5]
- + (uint64_t)a[1] * b[4]
- + (uint64_t)a[2] * b[3]
- + (uint64_t)a[3] * b[2]
- + (uint64_t)a[4] * b[1]
- + (uint64_t)a[5] * b[0];
- VERIFY_BITS(c, 63);
- /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
- d += (uint64_t)a[6] * b[9]
- + (uint64_t)a[7] * b[8]
- + (uint64_t)a[8] * b[7]
- + (uint64_t)a[9] * b[6];
- VERIFY_BITS(d, 62);
- /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
- u5 = d & M; d >>= 26; c += u5 * R0;
- VERIFY_BITS(u5, 26);
- VERIFY_BITS(d, 36);
- /* VERIFY_BITS(c, 64); */
- /* [d u5 0 0 0 0 0 t9 0 0 0 c-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
- t5 = c & M; c >>= 26; c += u5 * R1;
- VERIFY_BITS(t5, 26);
- VERIFY_BITS(c, 39);
- /* [d u5 0 0 0 0 0 t9 0 0 c-u5*R1 t5-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
-
- c += (uint64_t)a[0] * b[6]
- + (uint64_t)a[1] * b[5]
- + (uint64_t)a[2] * b[4]
- + (uint64_t)a[3] * b[3]
- + (uint64_t)a[4] * b[2]
- + (uint64_t)a[5] * b[1]
- + (uint64_t)a[6] * b[0];
- VERIFY_BITS(c, 63);
- /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
- d += (uint64_t)a[7] * b[9]
- + (uint64_t)a[8] * b[8]
- + (uint64_t)a[9] * b[7];
- VERIFY_BITS(d, 61);
- /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
- u6 = d & M; d >>= 26; c += u6 * R0;
- VERIFY_BITS(u6, 26);
- VERIFY_BITS(d, 35);
- /* VERIFY_BITS(c, 64); */
- /* [d u6 0 0 0 0 0 0 t9 0 0 c-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
- t6 = c & M; c >>= 26; c += u6 * R1;
- VERIFY_BITS(t6, 26);
- VERIFY_BITS(c, 39);
- /* [d u6 0 0 0 0 0 0 t9 0 c-u6*R1 t6-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
-
- c += (uint64_t)a[0] * b[7]
- + (uint64_t)a[1] * b[6]
- + (uint64_t)a[2] * b[5]
- + (uint64_t)a[3] * b[4]
- + (uint64_t)a[4] * b[3]
- + (uint64_t)a[5] * b[2]
- + (uint64_t)a[6] * b[1]
- + (uint64_t)a[7] * b[0];
- /* VERIFY_BITS(c, 64); */
- VERIFY_CHECK(c <= 0x8000007C00000007ULL);
- /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
- d += (uint64_t)a[8] * b[9]
- + (uint64_t)a[9] * b[8];
- VERIFY_BITS(d, 58);
- /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
- u7 = d & M; d >>= 26; c += u7 * R0;
- VERIFY_BITS(u7, 26);
- VERIFY_BITS(d, 32);
- /* VERIFY_BITS(c, 64); */
- VERIFY_CHECK(c <= 0x800001703FFFC2F7ULL);
- /* [d u7 0 0 0 0 0 0 0 t9 0 c-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
- t7 = c & M; c >>= 26; c += u7 * R1;
- VERIFY_BITS(t7, 26);
- VERIFY_BITS(c, 38);
- /* [d u7 0 0 0 0 0 0 0 t9 c-u7*R1 t7-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
-
- c += (uint64_t)a[0] * b[8]
- + (uint64_t)a[1] * b[7]
- + (uint64_t)a[2] * b[6]
- + (uint64_t)a[3] * b[5]
- + (uint64_t)a[4] * b[4]
- + (uint64_t)a[5] * b[3]
- + (uint64_t)a[6] * b[2]
- + (uint64_t)a[7] * b[1]
- + (uint64_t)a[8] * b[0];
- /* VERIFY_BITS(c, 64); */
- VERIFY_CHECK(c <= 0x9000007B80000008ULL);
- /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- d += (uint64_t)a[9] * b[9];
- VERIFY_BITS(d, 57);
- /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- u8 = d & M; d >>= 26; c += u8 * R0;
- VERIFY_BITS(u8, 26);
- VERIFY_BITS(d, 31);
- /* VERIFY_BITS(c, 64); */
- VERIFY_CHECK(c <= 0x9000016FBFFFC2F8ULL);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-
- r[3] = t3;
- VERIFY_BITS(r[3], 26);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[4] = t4;
- VERIFY_BITS(r[4], 26);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[5] = t5;
- VERIFY_BITS(r[5], 26);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[6] = t6;
- VERIFY_BITS(r[6], 26);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[7] = t7;
- VERIFY_BITS(r[7], 26);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-
- r[8] = c & M; c >>= 26; c += u8 * R1;
- VERIFY_BITS(r[8], 26);
- VERIFY_BITS(c, 39);
- /* [d u8 0 0 0 0 0 0 0 0 t9+c-u8*R1 r8-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 0 0 0 0 t9+c r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- c += d * R0 + t9;
- VERIFY_BITS(c, 45);
- /* [d 0 0 0 0 0 0 0 0 0 c-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[9] = c & (M >> 4); c >>= 22; c += d * (R1 << 4);
- VERIFY_BITS(r[9], 22);
- VERIFY_BITS(c, 46);
- /* [d 0 0 0 0 0 0 0 0 r9+((c-d*R1<<4)<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 0 0 -d*R1 r9+(c<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-
- d = c * (R0 >> 4) + t0;
- VERIFY_BITS(d, 56);
- /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 d-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[0] = d & M; d >>= 26;
- VERIFY_BITS(r[0], 26);
- VERIFY_BITS(d, 30);
- /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1+d r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- d += c * (R1 >> 4) + t1;
- VERIFY_BITS(d, 53);
- VERIFY_CHECK(d <= 0x10000003FFFFBFULL);
- /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 d-c*R1>>4 r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- /* [r9 r8 r7 r6 r5 r4 r3 t2 d r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[1] = d & M; d >>= 26;
- VERIFY_BITS(r[1], 26);
- VERIFY_BITS(d, 27);
- VERIFY_CHECK(d <= 0x4000000ULL);
- /* [r9 r8 r7 r6 r5 r4 r3 t2+d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- d += t2;
- VERIFY_BITS(d, 27);
- /* [r9 r8 r7 r6 r5 r4 r3 d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[2] = d;
- VERIFY_BITS(r[2], 27);
- /* [r9 r8 r7 r6 r5 r4 r3 r2 r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-}
-
-SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint32_t *r, const uint32_t *a) {
- uint64_t c, d;
- uint64_t u0, u1, u2, u3, u4, u5, u6, u7, u8;
- uint32_t t9, t0, t1, t2, t3, t4, t5, t6, t7;
- const uint32_t M = 0x3FFFFFFUL, R0 = 0x3D10UL, R1 = 0x400UL;
-
- VERIFY_BITS(a[0], 30);
- VERIFY_BITS(a[1], 30);
- VERIFY_BITS(a[2], 30);
- VERIFY_BITS(a[3], 30);
- VERIFY_BITS(a[4], 30);
- VERIFY_BITS(a[5], 30);
- VERIFY_BITS(a[6], 30);
- VERIFY_BITS(a[7], 30);
- VERIFY_BITS(a[8], 30);
- VERIFY_BITS(a[9], 26);
-
- /** [... a b c] is a shorthand for ... + a<<52 + b<<26 + c<<0 mod n.
- * px is a shorthand for sum(a[i]*a[x-i], i=0..x).
- * Note that [x 0 0 0 0 0 0 0 0 0 0] = [x*R1 x*R0].
- */
-
- d = (uint64_t)(a[0]*2) * a[9]
- + (uint64_t)(a[1]*2) * a[8]
- + (uint64_t)(a[2]*2) * a[7]
- + (uint64_t)(a[3]*2) * a[6]
- + (uint64_t)(a[4]*2) * a[5];
- /* VERIFY_BITS(d, 64); */
- /* [d 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
- t9 = d & M; d >>= 26;
- VERIFY_BITS(t9, 26);
- VERIFY_BITS(d, 38);
- /* [d t9 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
-
- c = (uint64_t)a[0] * a[0];
- VERIFY_BITS(c, 60);
- /* [d t9 0 0 0 0 0 0 0 0 c] = [p9 0 0 0 0 0 0 0 0 p0] */
- d += (uint64_t)(a[1]*2) * a[9]
- + (uint64_t)(a[2]*2) * a[8]
- + (uint64_t)(a[3]*2) * a[7]
- + (uint64_t)(a[4]*2) * a[6]
- + (uint64_t)a[5] * a[5];
- VERIFY_BITS(d, 63);
- /* [d t9 0 0 0 0 0 0 0 0 c] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
- u0 = d & M; d >>= 26; c += u0 * R0;
- VERIFY_BITS(u0, 26);
- VERIFY_BITS(d, 37);
- VERIFY_BITS(c, 61);
- /* [d u0 t9 0 0 0 0 0 0 0 0 c-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
- t0 = c & M; c >>= 26; c += u0 * R1;
- VERIFY_BITS(t0, 26);
- VERIFY_BITS(c, 37);
- /* [d u0 t9 0 0 0 0 0 0 0 c-u0*R1 t0-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
- /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
-
- c += (uint64_t)(a[0]*2) * a[1];
- VERIFY_BITS(c, 62);
- /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 p1 p0] */
- d += (uint64_t)(a[2]*2) * a[9]
- + (uint64_t)(a[3]*2) * a[8]
- + (uint64_t)(a[4]*2) * a[7]
- + (uint64_t)(a[5]*2) * a[6];
- VERIFY_BITS(d, 63);
- /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
- u1 = d & M; d >>= 26; c += u1 * R0;
- VERIFY_BITS(u1, 26);
- VERIFY_BITS(d, 37);
- VERIFY_BITS(c, 63);
- /* [d u1 0 t9 0 0 0 0 0 0 0 c-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
- t1 = c & M; c >>= 26; c += u1 * R1;
- VERIFY_BITS(t1, 26);
- VERIFY_BITS(c, 38);
- /* [d u1 0 t9 0 0 0 0 0 0 c-u1*R1 t1-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
- /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
-
- c += (uint64_t)(a[0]*2) * a[2]
- + (uint64_t)a[1] * a[1];
- VERIFY_BITS(c, 62);
- /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
- d += (uint64_t)(a[3]*2) * a[9]
- + (uint64_t)(a[4]*2) * a[8]
- + (uint64_t)(a[5]*2) * a[7]
- + (uint64_t)a[6] * a[6];
- VERIFY_BITS(d, 63);
- /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
- u2 = d & M; d >>= 26; c += u2 * R0;
- VERIFY_BITS(u2, 26);
- VERIFY_BITS(d, 37);
- VERIFY_BITS(c, 63);
- /* [d u2 0 0 t9 0 0 0 0 0 0 c-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
- t2 = c & M; c >>= 26; c += u2 * R1;
- VERIFY_BITS(t2, 26);
- VERIFY_BITS(c, 38);
- /* [d u2 0 0 t9 0 0 0 0 0 c-u2*R1 t2-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
- /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
-
- c += (uint64_t)(a[0]*2) * a[3]
- + (uint64_t)(a[1]*2) * a[2];
- VERIFY_BITS(c, 63);
- /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
- d += (uint64_t)(a[4]*2) * a[9]
- + (uint64_t)(a[5]*2) * a[8]
- + (uint64_t)(a[6]*2) * a[7];
- VERIFY_BITS(d, 63);
- /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
- u3 = d & M; d >>= 26; c += u3 * R0;
- VERIFY_BITS(u3, 26);
- VERIFY_BITS(d, 37);
- /* VERIFY_BITS(c, 64); */
- /* [d u3 0 0 0 t9 0 0 0 0 0 c-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
- t3 = c & M; c >>= 26; c += u3 * R1;
- VERIFY_BITS(t3, 26);
- VERIFY_BITS(c, 39);
- /* [d u3 0 0 0 t9 0 0 0 0 c-u3*R1 t3-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
- /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
-
- c += (uint64_t)(a[0]*2) * a[4]
- + (uint64_t)(a[1]*2) * a[3]
- + (uint64_t)a[2] * a[2];
- VERIFY_BITS(c, 63);
- /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
- d += (uint64_t)(a[5]*2) * a[9]
- + (uint64_t)(a[6]*2) * a[8]
- + (uint64_t)a[7] * a[7];
- VERIFY_BITS(d, 62);
- /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
- u4 = d & M; d >>= 26; c += u4 * R0;
- VERIFY_BITS(u4, 26);
- VERIFY_BITS(d, 36);
- /* VERIFY_BITS(c, 64); */
- /* [d u4 0 0 0 0 t9 0 0 0 0 c-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
- t4 = c & M; c >>= 26; c += u4 * R1;
- VERIFY_BITS(t4, 26);
- VERIFY_BITS(c, 39);
- /* [d u4 0 0 0 0 t9 0 0 0 c-u4*R1 t4-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
-
- c += (uint64_t)(a[0]*2) * a[5]
- + (uint64_t)(a[1]*2) * a[4]
- + (uint64_t)(a[2]*2) * a[3];
- VERIFY_BITS(c, 63);
- /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
- d += (uint64_t)(a[6]*2) * a[9]
- + (uint64_t)(a[7]*2) * a[8];
- VERIFY_BITS(d, 62);
- /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
- u5 = d & M; d >>= 26; c += u5 * R0;
- VERIFY_BITS(u5, 26);
- VERIFY_BITS(d, 36);
- /* VERIFY_BITS(c, 64); */
- /* [d u5 0 0 0 0 0 t9 0 0 0 c-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
- t5 = c & M; c >>= 26; c += u5 * R1;
- VERIFY_BITS(t5, 26);
- VERIFY_BITS(c, 39);
- /* [d u5 0 0 0 0 0 t9 0 0 c-u5*R1 t5-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
-
- c += (uint64_t)(a[0]*2) * a[6]
- + (uint64_t)(a[1]*2) * a[5]
- + (uint64_t)(a[2]*2) * a[4]
- + (uint64_t)a[3] * a[3];
- VERIFY_BITS(c, 63);
- /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
- d += (uint64_t)(a[7]*2) * a[9]
- + (uint64_t)a[8] * a[8];
- VERIFY_BITS(d, 61);
- /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
- u6 = d & M; d >>= 26; c += u6 * R0;
- VERIFY_BITS(u6, 26);
- VERIFY_BITS(d, 35);
- /* VERIFY_BITS(c, 64); */
- /* [d u6 0 0 0 0 0 0 t9 0 0 c-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
- t6 = c & M; c >>= 26; c += u6 * R1;
- VERIFY_BITS(t6, 26);
- VERIFY_BITS(c, 39);
- /* [d u6 0 0 0 0 0 0 t9 0 c-u6*R1 t6-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
-
- c += (uint64_t)(a[0]*2) * a[7]
- + (uint64_t)(a[1]*2) * a[6]
- + (uint64_t)(a[2]*2) * a[5]
- + (uint64_t)(a[3]*2) * a[4];
- /* VERIFY_BITS(c, 64); */
- VERIFY_CHECK(c <= 0x8000007C00000007ULL);
- /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
- d += (uint64_t)(a[8]*2) * a[9];
- VERIFY_BITS(d, 58);
- /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
- u7 = d & M; d >>= 26; c += u7 * R0;
- VERIFY_BITS(u7, 26);
- VERIFY_BITS(d, 32);
- /* VERIFY_BITS(c, 64); */
- VERIFY_CHECK(c <= 0x800001703FFFC2F7ULL);
- /* [d u7 0 0 0 0 0 0 0 t9 0 c-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
- t7 = c & M; c >>= 26; c += u7 * R1;
- VERIFY_BITS(t7, 26);
- VERIFY_BITS(c, 38);
- /* [d u7 0 0 0 0 0 0 0 t9 c-u7*R1 t7-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
-
- c += (uint64_t)(a[0]*2) * a[8]
- + (uint64_t)(a[1]*2) * a[7]
- + (uint64_t)(a[2]*2) * a[6]
- + (uint64_t)(a[3]*2) * a[5]
- + (uint64_t)a[4] * a[4];
- /* VERIFY_BITS(c, 64); */
- VERIFY_CHECK(c <= 0x9000007B80000008ULL);
- /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- d += (uint64_t)a[9] * a[9];
- VERIFY_BITS(d, 57);
- /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- u8 = d & M; d >>= 26; c += u8 * R0;
- VERIFY_BITS(u8, 26);
- VERIFY_BITS(d, 31);
- /* VERIFY_BITS(c, 64); */
- VERIFY_CHECK(c <= 0x9000016FBFFFC2F8ULL);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-
- r[3] = t3;
- VERIFY_BITS(r[3], 26);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[4] = t4;
- VERIFY_BITS(r[4], 26);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[5] = t5;
- VERIFY_BITS(r[5], 26);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[6] = t6;
- VERIFY_BITS(r[6], 26);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[7] = t7;
- VERIFY_BITS(r[7], 26);
- /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-
- r[8] = c & M; c >>= 26; c += u8 * R1;
- VERIFY_BITS(r[8], 26);
- VERIFY_BITS(c, 39);
- /* [d u8 0 0 0 0 0 0 0 0 t9+c-u8*R1 r8-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 0 0 0 0 t9+c r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- c += d * R0 + t9;
- VERIFY_BITS(c, 45);
- /* [d 0 0 0 0 0 0 0 0 0 c-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[9] = c & (M >> 4); c >>= 22; c += d * (R1 << 4);
- VERIFY_BITS(r[9], 22);
- VERIFY_BITS(c, 46);
- /* [d 0 0 0 0 0 0 0 0 r9+((c-d*R1<<4)<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- /* [d 0 0 0 0 0 0 0 -d*R1 r9+(c<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-
- d = c * (R0 >> 4) + t0;
- VERIFY_BITS(d, 56);
- /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 d-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[0] = d & M; d >>= 26;
- VERIFY_BITS(r[0], 26);
- VERIFY_BITS(d, 30);
- /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1+d r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- d += c * (R1 >> 4) + t1;
- VERIFY_BITS(d, 53);
- VERIFY_CHECK(d <= 0x10000003FFFFBFULL);
- /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 d-c*R1>>4 r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- /* [r9 r8 r7 r6 r5 r4 r3 t2 d r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[1] = d & M; d >>= 26;
- VERIFY_BITS(r[1], 26);
- VERIFY_BITS(d, 27);
- VERIFY_CHECK(d <= 0x4000000ULL);
- /* [r9 r8 r7 r6 r5 r4 r3 t2+d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- d += t2;
- VERIFY_BITS(d, 27);
- /* [r9 r8 r7 r6 r5 r4 r3 d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[2] = d;
- VERIFY_BITS(r[2], 27);
- /* [r9 r8 r7 r6 r5 r4 r3 r2 r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-}
-#endif
-
-static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
-#ifdef VERIFY
- VERIFY_CHECK(a->magnitude <= 8);
- VERIFY_CHECK(b->magnitude <= 8);
- secp256k1_fe_verify(a);
- secp256k1_fe_verify(b);
- VERIFY_CHECK(r != b);
-#endif
- secp256k1_fe_mul_inner(r->n, a->n, b->n);
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 0;
- secp256k1_fe_verify(r);
-#endif
-}
-
-static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
-#ifdef VERIFY
- VERIFY_CHECK(a->magnitude <= 8);
- secp256k1_fe_verify(a);
-#endif
- secp256k1_fe_sqr_inner(r->n, a->n);
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 0;
- secp256k1_fe_verify(r);
-#endif
-}
-
-static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag) {
- uint32_t mask0, mask1;
- mask0 = flag + ~((uint32_t)0);
- mask1 = ~mask0;
- r->n[0] = (r->n[0] & mask0) | (a->n[0] & mask1);
- r->n[1] = (r->n[1] & mask0) | (a->n[1] & mask1);
- r->n[2] = (r->n[2] & mask0) | (a->n[2] & mask1);
- r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
- r->n[4] = (r->n[4] & mask0) | (a->n[4] & mask1);
- r->n[5] = (r->n[5] & mask0) | (a->n[5] & mask1);
- r->n[6] = (r->n[6] & mask0) | (a->n[6] & mask1);
- r->n[7] = (r->n[7] & mask0) | (a->n[7] & mask1);
- r->n[8] = (r->n[8] & mask0) | (a->n[8] & mask1);
- r->n[9] = (r->n[9] & mask0) | (a->n[9] & mask1);
-#ifdef VERIFY
- if (a->magnitude > r->magnitude) {
- r->magnitude = a->magnitude;
- }
- r->normalized &= a->normalized;
-#endif
-}
-
-static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage *r, const secp256k1_fe_storage *a, int flag) {
- uint32_t mask0, mask1;
- mask0 = flag + ~((uint32_t)0);
- mask1 = ~mask0;
- r->n[0] = (r->n[0] & mask0) | (a->n[0] & mask1);
- r->n[1] = (r->n[1] & mask0) | (a->n[1] & mask1);
- r->n[2] = (r->n[2] & mask0) | (a->n[2] & mask1);
- r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
- r->n[4] = (r->n[4] & mask0) | (a->n[4] & mask1);
- r->n[5] = (r->n[5] & mask0) | (a->n[5] & mask1);
- r->n[6] = (r->n[6] & mask0) | (a->n[6] & mask1);
- r->n[7] = (r->n[7] & mask0) | (a->n[7] & mask1);
-}
-
-static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a) {
-#ifdef VERIFY
- VERIFY_CHECK(a->normalized);
-#endif
- r->n[0] = a->n[0] | a->n[1] << 26;
- r->n[1] = a->n[1] >> 6 | a->n[2] << 20;
- r->n[2] = a->n[2] >> 12 | a->n[3] << 14;
- r->n[3] = a->n[3] >> 18 | a->n[4] << 8;
- r->n[4] = a->n[4] >> 24 | a->n[5] << 2 | a->n[6] << 28;
- r->n[5] = a->n[6] >> 4 | a->n[7] << 22;
- r->n[6] = a->n[7] >> 10 | a->n[8] << 16;
- r->n[7] = a->n[8] >> 16 | a->n[9] << 10;
-}
-
-static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe *r, const secp256k1_fe_storage *a) {
- r->n[0] = a->n[0] & 0x3FFFFFFUL;
- r->n[1] = a->n[0] >> 26 | ((a->n[1] << 6) & 0x3FFFFFFUL);
- r->n[2] = a->n[1] >> 20 | ((a->n[2] << 12) & 0x3FFFFFFUL);
- r->n[3] = a->n[2] >> 14 | ((a->n[3] << 18) & 0x3FFFFFFUL);
- r->n[4] = a->n[3] >> 8 | ((a->n[4] << 24) & 0x3FFFFFFUL);
- r->n[5] = (a->n[4] >> 2) & 0x3FFFFFFUL;
- r->n[6] = a->n[4] >> 28 | ((a->n[5] << 4) & 0x3FFFFFFUL);
- r->n[7] = a->n[5] >> 22 | ((a->n[6] << 10) & 0x3FFFFFFUL);
- r->n[8] = a->n[6] >> 16 | ((a->n[7] << 16) & 0x3FFFFFFUL);
- r->n[9] = a->n[7] >> 10;
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 1;
-#endif
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/field_5x52.h op-geth/crypto/secp256k1/libsecp256k1/src/field_5x52.h
deleted file mode 100644
index 8e69a560dccb6c99621dee52f67a2502343453ca..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/field_5x52.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_FIELD_REPR_
-#define _SECP256K1_FIELD_REPR_
-
-#include <stdint.h>
-
-typedef struct {
- /* X = sum(i=0..4, elem[i]*2^52) mod n */
- uint64_t n[5];
-#ifdef VERIFY
- int magnitude;
- int normalized;
-#endif
-} secp256k1_fe;
-
-/* Unpacks a constant into a overlapping multi-limbed FE element. */
-#define SECP256K1_FE_CONST_INNER(d7, d6, d5, d4, d3, d2, d1, d0) { \
- (d0) | (((uint64_t)(d1) & 0xFFFFFUL) << 32), \
- ((uint64_t)(d1) >> 20) | (((uint64_t)(d2)) << 12) | (((uint64_t)(d3) & 0xFFUL) << 44), \
- ((uint64_t)(d3) >> 8) | (((uint64_t)(d4) & 0xFFFFFFFUL) << 24), \
- ((uint64_t)(d4) >> 28) | (((uint64_t)(d5)) << 4) | (((uint64_t)(d6) & 0xFFFFUL) << 36), \
- ((uint64_t)(d6) >> 16) | (((uint64_t)(d7)) << 16) \
-}
-
-#ifdef VERIFY
-#define SECP256K1_FE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {SECP256K1_FE_CONST_INNER((d7), (d6), (d5), (d4), (d3), (d2), (d1), (d0)), 1, 1}
-#else
-#define SECP256K1_FE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {SECP256K1_FE_CONST_INNER((d7), (d6), (d5), (d4), (d3), (d2), (d1), (d0))}
-#endif
-
-typedef struct {
- uint64_t n[4];
-} secp256k1_fe_storage;
-
-#define SECP256K1_FE_STORAGE_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{ \
- (d0) | (((uint64_t)(d1)) << 32), \
- (d2) | (((uint64_t)(d3)) << 32), \
- (d4) | (((uint64_t)(d5)) << 32), \
- (d6) | (((uint64_t)(d7)) << 32) \
-}}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/field_5x52_asm_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/field_5x52_asm_impl.h
deleted file mode 100644
index 98cc004bf04a69c201c996a7f1c3ccac68354b5e..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/field_5x52_asm_impl.h
+++ /dev/null
@@ -1,502 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013-2014 Diederik Huys, Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-/**
- * Changelog:
- * - March 2013, Diederik Huys: original version
- * - November 2014, Pieter Wuille: updated to use Peter Dettman's parallel multiplication algorithm
- * - December 2014, Pieter Wuille: converted from YASM to GCC inline assembly
- */
-
-#ifndef _SECP256K1_FIELD_INNER5X52_IMPL_H_
-#define _SECP256K1_FIELD_INNER5X52_IMPL_H_
-
-SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t *a, const uint64_t * SECP256K1_RESTRICT b) {
-/**
- * Registers: rdx:rax = multiplication accumulator
- * r9:r8 = c
- * r15:rcx = d
- * r10-r14 = a0-a4
- * rbx = b
- * rdi = r
- * rsi = a / t?
- */
- uint64_t tmp1, tmp2, tmp3;
-__asm__ __volatile__(
- "movq 0(%%rsi),%%r10\n"
- "movq 8(%%rsi),%%r11\n"
- "movq 16(%%rsi),%%r12\n"
- "movq 24(%%rsi),%%r13\n"
- "movq 32(%%rsi),%%r14\n"
-
- /* d += a3 * b0 */
- "movq 0(%%rbx),%%rax\n"
- "mulq %%r13\n"
- "movq %%rax,%%rcx\n"
- "movq %%rdx,%%r15\n"
- /* d += a2 * b1 */
- "movq 8(%%rbx),%%rax\n"
- "mulq %%r12\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += a1 * b2 */
- "movq 16(%%rbx),%%rax\n"
- "mulq %%r11\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d = a0 * b3 */
- "movq 24(%%rbx),%%rax\n"
- "mulq %%r10\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* c = a4 * b4 */
- "movq 32(%%rbx),%%rax\n"
- "mulq %%r14\n"
- "movq %%rax,%%r8\n"
- "movq %%rdx,%%r9\n"
- /* d += (c & M) * R */
- "movq $0xfffffffffffff,%%rdx\n"
- "andq %%rdx,%%rax\n"
- "movq $0x1000003d10,%%rdx\n"
- "mulq %%rdx\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* c >>= 52 (%%r8 only) */
- "shrdq $52,%%r9,%%r8\n"
- /* t3 (tmp1) = d & M */
- "movq %%rcx,%%rsi\n"
- "movq $0xfffffffffffff,%%rdx\n"
- "andq %%rdx,%%rsi\n"
- "movq %%rsi,%q1\n"
- /* d >>= 52 */
- "shrdq $52,%%r15,%%rcx\n"
- "xorq %%r15,%%r15\n"
- /* d += a4 * b0 */
- "movq 0(%%rbx),%%rax\n"
- "mulq %%r14\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += a3 * b1 */
- "movq 8(%%rbx),%%rax\n"
- "mulq %%r13\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += a2 * b2 */
- "movq 16(%%rbx),%%rax\n"
- "mulq %%r12\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += a1 * b3 */
- "movq 24(%%rbx),%%rax\n"
- "mulq %%r11\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += a0 * b4 */
- "movq 32(%%rbx),%%rax\n"
- "mulq %%r10\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += c * R */
- "movq %%r8,%%rax\n"
- "movq $0x1000003d10,%%rdx\n"
- "mulq %%rdx\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* t4 = d & M (%%rsi) */
- "movq %%rcx,%%rsi\n"
- "movq $0xfffffffffffff,%%rdx\n"
- "andq %%rdx,%%rsi\n"
- /* d >>= 52 */
- "shrdq $52,%%r15,%%rcx\n"
- "xorq %%r15,%%r15\n"
- /* tx = t4 >> 48 (tmp3) */
- "movq %%rsi,%%rax\n"
- "shrq $48,%%rax\n"
- "movq %%rax,%q3\n"
- /* t4 &= (M >> 4) (tmp2) */
- "movq $0xffffffffffff,%%rax\n"
- "andq %%rax,%%rsi\n"
- "movq %%rsi,%q2\n"
- /* c = a0 * b0 */
- "movq 0(%%rbx),%%rax\n"
- "mulq %%r10\n"
- "movq %%rax,%%r8\n"
- "movq %%rdx,%%r9\n"
- /* d += a4 * b1 */
- "movq 8(%%rbx),%%rax\n"
- "mulq %%r14\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += a3 * b2 */
- "movq 16(%%rbx),%%rax\n"
- "mulq %%r13\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += a2 * b3 */
- "movq 24(%%rbx),%%rax\n"
- "mulq %%r12\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += a1 * b4 */
- "movq 32(%%rbx),%%rax\n"
- "mulq %%r11\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* u0 = d & M (%%rsi) */
- "movq %%rcx,%%rsi\n"
- "movq $0xfffffffffffff,%%rdx\n"
- "andq %%rdx,%%rsi\n"
- /* d >>= 52 */
- "shrdq $52,%%r15,%%rcx\n"
- "xorq %%r15,%%r15\n"
- /* u0 = (u0 << 4) | tx (%%rsi) */
- "shlq $4,%%rsi\n"
- "movq %q3,%%rax\n"
- "orq %%rax,%%rsi\n"
- /* c += u0 * (R >> 4) */
- "movq $0x1000003d1,%%rax\n"
- "mulq %%rsi\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* r[0] = c & M */
- "movq %%r8,%%rax\n"
- "movq $0xfffffffffffff,%%rdx\n"
- "andq %%rdx,%%rax\n"
- "movq %%rax,0(%%rdi)\n"
- /* c >>= 52 */
- "shrdq $52,%%r9,%%r8\n"
- "xorq %%r9,%%r9\n"
- /* c += a1 * b0 */
- "movq 0(%%rbx),%%rax\n"
- "mulq %%r11\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* c += a0 * b1 */
- "movq 8(%%rbx),%%rax\n"
- "mulq %%r10\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* d += a4 * b2 */
- "movq 16(%%rbx),%%rax\n"
- "mulq %%r14\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += a3 * b3 */
- "movq 24(%%rbx),%%rax\n"
- "mulq %%r13\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += a2 * b4 */
- "movq 32(%%rbx),%%rax\n"
- "mulq %%r12\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* c += (d & M) * R */
- "movq %%rcx,%%rax\n"
- "movq $0xfffffffffffff,%%rdx\n"
- "andq %%rdx,%%rax\n"
- "movq $0x1000003d10,%%rdx\n"
- "mulq %%rdx\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* d >>= 52 */
- "shrdq $52,%%r15,%%rcx\n"
- "xorq %%r15,%%r15\n"
- /* r[1] = c & M */
- "movq %%r8,%%rax\n"
- "movq $0xfffffffffffff,%%rdx\n"
- "andq %%rdx,%%rax\n"
- "movq %%rax,8(%%rdi)\n"
- /* c >>= 52 */
- "shrdq $52,%%r9,%%r8\n"
- "xorq %%r9,%%r9\n"
- /* c += a2 * b0 */
- "movq 0(%%rbx),%%rax\n"
- "mulq %%r12\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* c += a1 * b1 */
- "movq 8(%%rbx),%%rax\n"
- "mulq %%r11\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* c += a0 * b2 (last use of %%r10 = a0) */
- "movq 16(%%rbx),%%rax\n"
- "mulq %%r10\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* fetch t3 (%%r10, overwrites a0), t4 (%%rsi) */
- "movq %q2,%%rsi\n"
- "movq %q1,%%r10\n"
- /* d += a4 * b3 */
- "movq 24(%%rbx),%%rax\n"
- "mulq %%r14\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* d += a3 * b4 */
- "movq 32(%%rbx),%%rax\n"
- "mulq %%r13\n"
- "addq %%rax,%%rcx\n"
- "adcq %%rdx,%%r15\n"
- /* c += (d & M) * R */
- "movq %%rcx,%%rax\n"
- "movq $0xfffffffffffff,%%rdx\n"
- "andq %%rdx,%%rax\n"
- "movq $0x1000003d10,%%rdx\n"
- "mulq %%rdx\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* d >>= 52 (%%rcx only) */
- "shrdq $52,%%r15,%%rcx\n"
- /* r[2] = c & M */
- "movq %%r8,%%rax\n"
- "movq $0xfffffffffffff,%%rdx\n"
- "andq %%rdx,%%rax\n"
- "movq %%rax,16(%%rdi)\n"
- /* c >>= 52 */
- "shrdq $52,%%r9,%%r8\n"
- "xorq %%r9,%%r9\n"
- /* c += t3 */
- "addq %%r10,%%r8\n"
- /* c += d * R */
- "movq %%rcx,%%rax\n"
- "movq $0x1000003d10,%%rdx\n"
- "mulq %%rdx\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* r[3] = c & M */
- "movq %%r8,%%rax\n"
- "movq $0xfffffffffffff,%%rdx\n"
- "andq %%rdx,%%rax\n"
- "movq %%rax,24(%%rdi)\n"
- /* c >>= 52 (%%r8 only) */
- "shrdq $52,%%r9,%%r8\n"
- /* c += t4 (%%r8 only) */
- "addq %%rsi,%%r8\n"
- /* r[4] = c */
- "movq %%r8,32(%%rdi)\n"
-: "+S"(a), "=m"(tmp1), "=m"(tmp2), "=m"(tmp3)
-: "b"(b), "D"(r)
-: "%rax", "%rcx", "%rdx", "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15", "cc", "memory"
-);
-}
-
-SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const uint64_t *a) {
-/**
- * Registers: rdx:rax = multiplication accumulator
- * r9:r8 = c
- * rcx:rbx = d
- * r10-r14 = a0-a4
- * r15 = M (0xfffffffffffff)
- * rdi = r
- * rsi = a / t?
- */
- uint64_t tmp1, tmp2, tmp3;
-__asm__ __volatile__(
- "movq 0(%%rsi),%%r10\n"
- "movq 8(%%rsi),%%r11\n"
- "movq 16(%%rsi),%%r12\n"
- "movq 24(%%rsi),%%r13\n"
- "movq 32(%%rsi),%%r14\n"
- "movq $0xfffffffffffff,%%r15\n"
-
- /* d = (a0*2) * a3 */
- "leaq (%%r10,%%r10,1),%%rax\n"
- "mulq %%r13\n"
- "movq %%rax,%%rbx\n"
- "movq %%rdx,%%rcx\n"
- /* d += (a1*2) * a2 */
- "leaq (%%r11,%%r11,1),%%rax\n"
- "mulq %%r12\n"
- "addq %%rax,%%rbx\n"
- "adcq %%rdx,%%rcx\n"
- /* c = a4 * a4 */
- "movq %%r14,%%rax\n"
- "mulq %%r14\n"
- "movq %%rax,%%r8\n"
- "movq %%rdx,%%r9\n"
- /* d += (c & M) * R */
- "andq %%r15,%%rax\n"
- "movq $0x1000003d10,%%rdx\n"
- "mulq %%rdx\n"
- "addq %%rax,%%rbx\n"
- "adcq %%rdx,%%rcx\n"
- /* c >>= 52 (%%r8 only) */
- "shrdq $52,%%r9,%%r8\n"
- /* t3 (tmp1) = d & M */
- "movq %%rbx,%%rsi\n"
- "andq %%r15,%%rsi\n"
- "movq %%rsi,%q1\n"
- /* d >>= 52 */
- "shrdq $52,%%rcx,%%rbx\n"
- "xorq %%rcx,%%rcx\n"
- /* a4 *= 2 */
- "addq %%r14,%%r14\n"
- /* d += a0 * a4 */
- "movq %%r10,%%rax\n"
- "mulq %%r14\n"
- "addq %%rax,%%rbx\n"
- "adcq %%rdx,%%rcx\n"
- /* d+= (a1*2) * a3 */
- "leaq (%%r11,%%r11,1),%%rax\n"
- "mulq %%r13\n"
- "addq %%rax,%%rbx\n"
- "adcq %%rdx,%%rcx\n"
- /* d += a2 * a2 */
- "movq %%r12,%%rax\n"
- "mulq %%r12\n"
- "addq %%rax,%%rbx\n"
- "adcq %%rdx,%%rcx\n"
- /* d += c * R */
- "movq %%r8,%%rax\n"
- "movq $0x1000003d10,%%rdx\n"
- "mulq %%rdx\n"
- "addq %%rax,%%rbx\n"
- "adcq %%rdx,%%rcx\n"
- /* t4 = d & M (%%rsi) */
- "movq %%rbx,%%rsi\n"
- "andq %%r15,%%rsi\n"
- /* d >>= 52 */
- "shrdq $52,%%rcx,%%rbx\n"
- "xorq %%rcx,%%rcx\n"
- /* tx = t4 >> 48 (tmp3) */
- "movq %%rsi,%%rax\n"
- "shrq $48,%%rax\n"
- "movq %%rax,%q3\n"
- /* t4 &= (M >> 4) (tmp2) */
- "movq $0xffffffffffff,%%rax\n"
- "andq %%rax,%%rsi\n"
- "movq %%rsi,%q2\n"
- /* c = a0 * a0 */
- "movq %%r10,%%rax\n"
- "mulq %%r10\n"
- "movq %%rax,%%r8\n"
- "movq %%rdx,%%r9\n"
- /* d += a1 * a4 */
- "movq %%r11,%%rax\n"
- "mulq %%r14\n"
- "addq %%rax,%%rbx\n"
- "adcq %%rdx,%%rcx\n"
- /* d += (a2*2) * a3 */
- "leaq (%%r12,%%r12,1),%%rax\n"
- "mulq %%r13\n"
- "addq %%rax,%%rbx\n"
- "adcq %%rdx,%%rcx\n"
- /* u0 = d & M (%%rsi) */
- "movq %%rbx,%%rsi\n"
- "andq %%r15,%%rsi\n"
- /* d >>= 52 */
- "shrdq $52,%%rcx,%%rbx\n"
- "xorq %%rcx,%%rcx\n"
- /* u0 = (u0 << 4) | tx (%%rsi) */
- "shlq $4,%%rsi\n"
- "movq %q3,%%rax\n"
- "orq %%rax,%%rsi\n"
- /* c += u0 * (R >> 4) */
- "movq $0x1000003d1,%%rax\n"
- "mulq %%rsi\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* r[0] = c & M */
- "movq %%r8,%%rax\n"
- "andq %%r15,%%rax\n"
- "movq %%rax,0(%%rdi)\n"
- /* c >>= 52 */
- "shrdq $52,%%r9,%%r8\n"
- "xorq %%r9,%%r9\n"
- /* a0 *= 2 */
- "addq %%r10,%%r10\n"
- /* c += a0 * a1 */
- "movq %%r10,%%rax\n"
- "mulq %%r11\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* d += a2 * a4 */
- "movq %%r12,%%rax\n"
- "mulq %%r14\n"
- "addq %%rax,%%rbx\n"
- "adcq %%rdx,%%rcx\n"
- /* d += a3 * a3 */
- "movq %%r13,%%rax\n"
- "mulq %%r13\n"
- "addq %%rax,%%rbx\n"
- "adcq %%rdx,%%rcx\n"
- /* c += (d & M) * R */
- "movq %%rbx,%%rax\n"
- "andq %%r15,%%rax\n"
- "movq $0x1000003d10,%%rdx\n"
- "mulq %%rdx\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* d >>= 52 */
- "shrdq $52,%%rcx,%%rbx\n"
- "xorq %%rcx,%%rcx\n"
- /* r[1] = c & M */
- "movq %%r8,%%rax\n"
- "andq %%r15,%%rax\n"
- "movq %%rax,8(%%rdi)\n"
- /* c >>= 52 */
- "shrdq $52,%%r9,%%r8\n"
- "xorq %%r9,%%r9\n"
- /* c += a0 * a2 (last use of %%r10) */
- "movq %%r10,%%rax\n"
- "mulq %%r12\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* fetch t3 (%%r10, overwrites a0),t4 (%%rsi) */
- "movq %q2,%%rsi\n"
- "movq %q1,%%r10\n"
- /* c += a1 * a1 */
- "movq %%r11,%%rax\n"
- "mulq %%r11\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* d += a3 * a4 */
- "movq %%r13,%%rax\n"
- "mulq %%r14\n"
- "addq %%rax,%%rbx\n"
- "adcq %%rdx,%%rcx\n"
- /* c += (d & M) * R */
- "movq %%rbx,%%rax\n"
- "andq %%r15,%%rax\n"
- "movq $0x1000003d10,%%rdx\n"
- "mulq %%rdx\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* d >>= 52 (%%rbx only) */
- "shrdq $52,%%rcx,%%rbx\n"
- /* r[2] = c & M */
- "movq %%r8,%%rax\n"
- "andq %%r15,%%rax\n"
- "movq %%rax,16(%%rdi)\n"
- /* c >>= 52 */
- "shrdq $52,%%r9,%%r8\n"
- "xorq %%r9,%%r9\n"
- /* c += t3 */
- "addq %%r10,%%r8\n"
- /* c += d * R */
- "movq %%rbx,%%rax\n"
- "movq $0x1000003d10,%%rdx\n"
- "mulq %%rdx\n"
- "addq %%rax,%%r8\n"
- "adcq %%rdx,%%r9\n"
- /* r[3] = c & M */
- "movq %%r8,%%rax\n"
- "andq %%r15,%%rax\n"
- "movq %%rax,24(%%rdi)\n"
- /* c >>= 52 (%%r8 only) */
- "shrdq $52,%%r9,%%r8\n"
- /* c += t4 (%%r8 only) */
- "addq %%rsi,%%r8\n"
- /* r[4] = c */
- "movq %%r8,32(%%rdi)\n"
-: "+S"(a), "=m"(tmp1), "=m"(tmp2), "=m"(tmp3)
-: "D"(r)
-: "%rax", "%rbx", "%rcx", "%rdx", "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15", "cc", "memory"
-);
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/field_5x52_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/field_5x52_impl.h
deleted file mode 100644
index dd88f38c77bbc5f0b86772b8d680c3f769e05a11..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/field_5x52_impl.h
+++ /dev/null
@@ -1,451 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_FIELD_REPR_IMPL_H_
-#define _SECP256K1_FIELD_REPR_IMPL_H_
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#include "util.h"
-#include "num.h"
-#include "field.h"
-
-#if defined(USE_ASM_X86_64)
-#include "field_5x52_asm_impl.h"
-#else
-#include "field_5x52_int128_impl.h"
-#endif
-
-/** Implements arithmetic modulo FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE FFFFFC2F,
- * represented as 5 uint64_t's in base 2^52. The values are allowed to contain >52 each. In particular,
- * each FieldElem has a 'magnitude' associated with it. Internally, a magnitude M means each element
- * is at most M*(2^53-1), except the most significant one, which is limited to M*(2^49-1). All operations
- * accept any input with magnitude at most M, and have different rules for propagating magnitude to their
- * output.
- */
-
-#ifdef VERIFY
-static void secp256k1_fe_verify(const secp256k1_fe *a) {
- const uint64_t *d = a->n;
- int m = a->normalized ? 1 : 2 * a->magnitude, r = 1;
- /* secp256k1 'p' value defined in "Standards for Efficient Cryptography" (SEC2) 2.7.1. */
- r &= (d[0] <= 0xFFFFFFFFFFFFFULL * m);
- r &= (d[1] <= 0xFFFFFFFFFFFFFULL * m);
- r &= (d[2] <= 0xFFFFFFFFFFFFFULL * m);
- r &= (d[3] <= 0xFFFFFFFFFFFFFULL * m);
- r &= (d[4] <= 0x0FFFFFFFFFFFFULL * m);
- r &= (a->magnitude >= 0);
- r &= (a->magnitude <= 2048);
- if (a->normalized) {
- r &= (a->magnitude <= 1);
- if (r && (d[4] == 0x0FFFFFFFFFFFFULL) && ((d[3] & d[2] & d[1]) == 0xFFFFFFFFFFFFFULL)) {
- r &= (d[0] < 0xFFFFEFFFFFC2FULL);
- }
- }
- VERIFY_CHECK(r == 1);
-}
-#endif
-
-static void secp256k1_fe_normalize(secp256k1_fe *r) {
- uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
-
- /* Reduce t4 at the start so there will be at most a single carry from the first pass */
- uint64_t m;
- uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
-
- /* The first pass ensures the magnitude is 1, ... */
- t0 += x * 0x1000003D1ULL;
- t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
- t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; m = t1;
- t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; m &= t2;
- t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; m &= t3;
-
- /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
- VERIFY_CHECK(t4 >> 49 == 0);
-
- /* At most a single final reduction is needed; check if the value is >= the field characteristic */
- x = (t4 >> 48) | ((t4 == 0x0FFFFFFFFFFFFULL) & (m == 0xFFFFFFFFFFFFFULL)
- & (t0 >= 0xFFFFEFFFFFC2FULL));
-
- /* Apply the final reduction (for constant-time behaviour, we do it always) */
- t0 += x * 0x1000003D1ULL;
- t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
- t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
- t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
- t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL;
-
- /* If t4 didn't carry to bit 48 already, then it should have after any final reduction */
- VERIFY_CHECK(t4 >> 48 == x);
-
- /* Mask off the possible multiple of 2^256 from the final reduction */
- t4 &= 0x0FFFFFFFFFFFFULL;
-
- r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
-
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 1;
- secp256k1_fe_verify(r);
-#endif
-}
-
-static void secp256k1_fe_normalize_weak(secp256k1_fe *r) {
- uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
-
- /* Reduce t4 at the start so there will be at most a single carry from the first pass */
- uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
-
- /* The first pass ensures the magnitude is 1, ... */
- t0 += x * 0x1000003D1ULL;
- t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
- t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
- t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
- t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL;
-
- /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
- VERIFY_CHECK(t4 >> 49 == 0);
-
- r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
-
-#ifdef VERIFY
- r->magnitude = 1;
- secp256k1_fe_verify(r);
-#endif
-}
-
-static void secp256k1_fe_normalize_var(secp256k1_fe *r) {
- uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
-
- /* Reduce t4 at the start so there will be at most a single carry from the first pass */
- uint64_t m;
- uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
-
- /* The first pass ensures the magnitude is 1, ... */
- t0 += x * 0x1000003D1ULL;
- t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
- t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; m = t1;
- t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; m &= t2;
- t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; m &= t3;
-
- /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
- VERIFY_CHECK(t4 >> 49 == 0);
-
- /* At most a single final reduction is needed; check if the value is >= the field characteristic */
- x = (t4 >> 48) | ((t4 == 0x0FFFFFFFFFFFFULL) & (m == 0xFFFFFFFFFFFFFULL)
- & (t0 >= 0xFFFFEFFFFFC2FULL));
-
- if (x) {
- t0 += 0x1000003D1ULL;
- t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
- t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
- t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
- t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL;
-
- /* If t4 didn't carry to bit 48 already, then it should have after any final reduction */
- VERIFY_CHECK(t4 >> 48 == x);
-
- /* Mask off the possible multiple of 2^256 from the final reduction */
- t4 &= 0x0FFFFFFFFFFFFULL;
- }
-
- r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
-
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 1;
- secp256k1_fe_verify(r);
-#endif
-}
-
-static int secp256k1_fe_normalizes_to_zero(secp256k1_fe *r) {
- uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
-
- /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
- uint64_t z0, z1;
-
- /* Reduce t4 at the start so there will be at most a single carry from the first pass */
- uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
-
- /* The first pass ensures the magnitude is 1, ... */
- t0 += x * 0x1000003D1ULL;
- t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL; z0 = t0; z1 = t0 ^ 0x1000003D0ULL;
- t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; z0 |= t1; z1 &= t1;
- t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; z0 |= t2; z1 &= t2;
- t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; z0 |= t3; z1 &= t3;
- z0 |= t4; z1 &= t4 ^ 0xF000000000000ULL;
-
- /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
- VERIFY_CHECK(t4 >> 49 == 0);
-
- return (z0 == 0) | (z1 == 0xFFFFFFFFFFFFFULL);
-}
-
-static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe *r) {
- uint64_t t0, t1, t2, t3, t4;
- uint64_t z0, z1;
- uint64_t x;
-
- t0 = r->n[0];
- t4 = r->n[4];
-
- /* Reduce t4 at the start so there will be at most a single carry from the first pass */
- x = t4 >> 48;
-
- /* The first pass ensures the magnitude is 1, ... */
- t0 += x * 0x1000003D1ULL;
-
- /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
- z0 = t0 & 0xFFFFFFFFFFFFFULL;
- z1 = z0 ^ 0x1000003D0ULL;
-
- /* Fast return path should catch the majority of cases */
- if ((z0 != 0ULL) & (z1 != 0xFFFFFFFFFFFFFULL)) {
- return 0;
- }
-
- t1 = r->n[1];
- t2 = r->n[2];
- t3 = r->n[3];
-
- t4 &= 0x0FFFFFFFFFFFFULL;
-
- t1 += (t0 >> 52);
- t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; z0 |= t1; z1 &= t1;
- t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; z0 |= t2; z1 &= t2;
- t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; z0 |= t3; z1 &= t3;
- z0 |= t4; z1 &= t4 ^ 0xF000000000000ULL;
-
- /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
- VERIFY_CHECK(t4 >> 49 == 0);
-
- return (z0 == 0) | (z1 == 0xFFFFFFFFFFFFFULL);
-}
-
-SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe *r, int a) {
- r->n[0] = a;
- r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 1;
- secp256k1_fe_verify(r);
-#endif
-}
-
-SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe *a) {
- const uint64_t *t = a->n;
-#ifdef VERIFY
- VERIFY_CHECK(a->normalized);
- secp256k1_fe_verify(a);
-#endif
- return (t[0] | t[1] | t[2] | t[3] | t[4]) == 0;
-}
-
-SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe *a) {
-#ifdef VERIFY
- VERIFY_CHECK(a->normalized);
- secp256k1_fe_verify(a);
-#endif
- return a->n[0] & 1;
-}
-
-SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
- int i;
-#ifdef VERIFY
- a->magnitude = 0;
- a->normalized = 1;
-#endif
- for (i=0; i<5; i++) {
- a->n[i] = 0;
- }
-}
-
-static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_fe *b) {
- int i;
-#ifdef VERIFY
- VERIFY_CHECK(a->normalized);
- VERIFY_CHECK(b->normalized);
- secp256k1_fe_verify(a);
- secp256k1_fe_verify(b);
-#endif
- for (i = 4; i >= 0; i--) {
- if (a->n[i] > b->n[i]) {
- return 1;
- }
- if (a->n[i] < b->n[i]) {
- return -1;
- }
- }
- return 0;
-}
-
-static int secp256k1_fe_set_b32(secp256k1_fe *r, const unsigned char *a) {
- int i;
- r->n[0] = r->n[1] = r->n[2] = r->n[3] = r->n[4] = 0;
- for (i=0; i<32; i++) {
- int j;
- for (j=0; j<2; j++) {
- int limb = (8*i+4*j)/52;
- int shift = (8*i+4*j)%52;
- r->n[limb] |= (uint64_t)((a[31-i] >> (4*j)) & 0xF) << shift;
- }
- }
- if (r->n[4] == 0x0FFFFFFFFFFFFULL && (r->n[3] & r->n[2] & r->n[1]) == 0xFFFFFFFFFFFFFULL && r->n[0] >= 0xFFFFEFFFFFC2FULL) {
- return 0;
- }
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 1;
- secp256k1_fe_verify(r);
-#endif
- return 1;
-}
-
-/** Convert a field element to a 32-byte big endian value. Requires the input to be normalized */
-static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a) {
- int i;
-#ifdef VERIFY
- VERIFY_CHECK(a->normalized);
- secp256k1_fe_verify(a);
-#endif
- for (i=0; i<32; i++) {
- int j;
- int c = 0;
- for (j=0; j<2; j++) {
- int limb = (8*i+4*j)/52;
- int shift = (8*i+4*j)%52;
- c |= ((a->n[limb] >> shift) & 0xF) << (4 * j);
- }
- r[31-i] = c;
- }
-}
-
-SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe *r, const secp256k1_fe *a, int m) {
-#ifdef VERIFY
- VERIFY_CHECK(a->magnitude <= m);
- secp256k1_fe_verify(a);
-#endif
- r->n[0] = 0xFFFFEFFFFFC2FULL * 2 * (m + 1) - a->n[0];
- r->n[1] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[1];
- r->n[2] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[2];
- r->n[3] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[3];
- r->n[4] = 0x0FFFFFFFFFFFFULL * 2 * (m + 1) - a->n[4];
-#ifdef VERIFY
- r->magnitude = m + 1;
- r->normalized = 0;
- secp256k1_fe_verify(r);
-#endif
-}
-
-SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe *r, int a) {
- r->n[0] *= a;
- r->n[1] *= a;
- r->n[2] *= a;
- r->n[3] *= a;
- r->n[4] *= a;
-#ifdef VERIFY
- r->magnitude *= a;
- r->normalized = 0;
- secp256k1_fe_verify(r);
-#endif
-}
-
-SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe *r, const secp256k1_fe *a) {
-#ifdef VERIFY
- secp256k1_fe_verify(a);
-#endif
- r->n[0] += a->n[0];
- r->n[1] += a->n[1];
- r->n[2] += a->n[2];
- r->n[3] += a->n[3];
- r->n[4] += a->n[4];
-#ifdef VERIFY
- r->magnitude += a->magnitude;
- r->normalized = 0;
- secp256k1_fe_verify(r);
-#endif
-}
-
-static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
-#ifdef VERIFY
- VERIFY_CHECK(a->magnitude <= 8);
- VERIFY_CHECK(b->magnitude <= 8);
- secp256k1_fe_verify(a);
- secp256k1_fe_verify(b);
- VERIFY_CHECK(r != b);
-#endif
- secp256k1_fe_mul_inner(r->n, a->n, b->n);
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 0;
- secp256k1_fe_verify(r);
-#endif
-}
-
-static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
-#ifdef VERIFY
- VERIFY_CHECK(a->magnitude <= 8);
- secp256k1_fe_verify(a);
-#endif
- secp256k1_fe_sqr_inner(r->n, a->n);
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 0;
- secp256k1_fe_verify(r);
-#endif
-}
-
-static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag) {
- uint64_t mask0, mask1;
- mask0 = flag + ~((uint64_t)0);
- mask1 = ~mask0;
- r->n[0] = (r->n[0] & mask0) | (a->n[0] & mask1);
- r->n[1] = (r->n[1] & mask0) | (a->n[1] & mask1);
- r->n[2] = (r->n[2] & mask0) | (a->n[2] & mask1);
- r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
- r->n[4] = (r->n[4] & mask0) | (a->n[4] & mask1);
-#ifdef VERIFY
- if (a->magnitude > r->magnitude) {
- r->magnitude = a->magnitude;
- }
- r->normalized &= a->normalized;
-#endif
-}
-
-static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage *r, const secp256k1_fe_storage *a, int flag) {
- uint64_t mask0, mask1;
- mask0 = flag + ~((uint64_t)0);
- mask1 = ~mask0;
- r->n[0] = (r->n[0] & mask0) | (a->n[0] & mask1);
- r->n[1] = (r->n[1] & mask0) | (a->n[1] & mask1);
- r->n[2] = (r->n[2] & mask0) | (a->n[2] & mask1);
- r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
-}
-
-static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a) {
-#ifdef VERIFY
- VERIFY_CHECK(a->normalized);
-#endif
- r->n[0] = a->n[0] | a->n[1] << 52;
- r->n[1] = a->n[1] >> 12 | a->n[2] << 40;
- r->n[2] = a->n[2] >> 24 | a->n[3] << 28;
- r->n[3] = a->n[3] >> 36 | a->n[4] << 16;
-}
-
-static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe *r, const secp256k1_fe_storage *a) {
- r->n[0] = a->n[0] & 0xFFFFFFFFFFFFFULL;
- r->n[1] = a->n[0] >> 52 | ((a->n[1] << 12) & 0xFFFFFFFFFFFFFULL);
- r->n[2] = a->n[1] >> 40 | ((a->n[2] << 24) & 0xFFFFFFFFFFFFFULL);
- r->n[3] = a->n[2] >> 28 | ((a->n[3] << 36) & 0xFFFFFFFFFFFFFULL);
- r->n[4] = a->n[3] >> 16;
-#ifdef VERIFY
- r->magnitude = 1;
- r->normalized = 1;
-#endif
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/field_5x52_int128_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/field_5x52_int128_impl.h
deleted file mode 100644
index 0bf22bdd3ec887251346dac826291fd1432c13ce..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/field_5x52_int128_impl.h
+++ /dev/null
@@ -1,277 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_FIELD_INNER5X52_IMPL_H_
-#define _SECP256K1_FIELD_INNER5X52_IMPL_H_
-
-#include <stdint.h>
-
-#ifdef VERIFY
-#define VERIFY_BITS(x, n) VERIFY_CHECK(((x) >> (n)) == 0)
-#else
-#define VERIFY_BITS(x, n) do { } while(0)
-#endif
-
-SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t *a, const uint64_t * SECP256K1_RESTRICT b) {
- uint128_t c, d;
- uint64_t t3, t4, tx, u0;
- uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
- const uint64_t M = 0xFFFFFFFFFFFFFULL, R = 0x1000003D10ULL;
-
- VERIFY_BITS(a[0], 56);
- VERIFY_BITS(a[1], 56);
- VERIFY_BITS(a[2], 56);
- VERIFY_BITS(a[3], 56);
- VERIFY_BITS(a[4], 52);
- VERIFY_BITS(b[0], 56);
- VERIFY_BITS(b[1], 56);
- VERIFY_BITS(b[2], 56);
- VERIFY_BITS(b[3], 56);
- VERIFY_BITS(b[4], 52);
- VERIFY_CHECK(r != b);
-
- /* [... a b c] is a shorthand for ... + a<<104 + b<<52 + c<<0 mod n.
- * px is a shorthand for sum(a[i]*b[x-i], i=0..x).
- * Note that [x 0 0 0 0 0] = [x*R].
- */
-
- d = (uint128_t)a0 * b[3]
- + (uint128_t)a1 * b[2]
- + (uint128_t)a2 * b[1]
- + (uint128_t)a3 * b[0];
- VERIFY_BITS(d, 114);
- /* [d 0 0 0] = [p3 0 0 0] */
- c = (uint128_t)a4 * b[4];
- VERIFY_BITS(c, 112);
- /* [c 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
- d += (c & M) * R; c >>= 52;
- VERIFY_BITS(d, 115);
- VERIFY_BITS(c, 60);
- /* [c 0 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
- t3 = d & M; d >>= 52;
- VERIFY_BITS(t3, 52);
- VERIFY_BITS(d, 63);
- /* [c 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
-
- d += (uint128_t)a0 * b[4]
- + (uint128_t)a1 * b[3]
- + (uint128_t)a2 * b[2]
- + (uint128_t)a3 * b[1]
- + (uint128_t)a4 * b[0];
- VERIFY_BITS(d, 115);
- /* [c 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
- d += c * R;
- VERIFY_BITS(d, 116);
- /* [d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
- t4 = d & M; d >>= 52;
- VERIFY_BITS(t4, 52);
- VERIFY_BITS(d, 64);
- /* [d t4 t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
- tx = (t4 >> 48); t4 &= (M >> 4);
- VERIFY_BITS(tx, 4);
- VERIFY_BITS(t4, 48);
- /* [d t4+(tx<<48) t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
-
- c = (uint128_t)a0 * b[0];
- VERIFY_BITS(c, 112);
- /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 0 p4 p3 0 0 p0] */
- d += (uint128_t)a1 * b[4]
- + (uint128_t)a2 * b[3]
- + (uint128_t)a3 * b[2]
- + (uint128_t)a4 * b[1];
- VERIFY_BITS(d, 115);
- /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
- u0 = d & M; d >>= 52;
- VERIFY_BITS(u0, 52);
- VERIFY_BITS(d, 63);
- /* [d u0 t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
- /* [d 0 t4+(tx<<48)+(u0<<52) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
- u0 = (u0 << 4) | tx;
- VERIFY_BITS(u0, 56);
- /* [d 0 t4+(u0<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
- c += (uint128_t)u0 * (R >> 4);
- VERIFY_BITS(c, 115);
- /* [d 0 t4 t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
- r[0] = c & M; c >>= 52;
- VERIFY_BITS(r[0], 52);
- VERIFY_BITS(c, 61);
- /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 0 p0] */
-
- c += (uint128_t)a0 * b[1]
- + (uint128_t)a1 * b[0];
- VERIFY_BITS(c, 114);
- /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 p1 p0] */
- d += (uint128_t)a2 * b[4]
- + (uint128_t)a3 * b[3]
- + (uint128_t)a4 * b[2];
- VERIFY_BITS(d, 114);
- /* [d 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
- c += (d & M) * R; d >>= 52;
- VERIFY_BITS(c, 115);
- VERIFY_BITS(d, 62);
- /* [d 0 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
- r[1] = c & M; c >>= 52;
- VERIFY_BITS(r[1], 52);
- VERIFY_BITS(c, 63);
- /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
-
- c += (uint128_t)a0 * b[2]
- + (uint128_t)a1 * b[1]
- + (uint128_t)a2 * b[0];
- VERIFY_BITS(c, 114);
- /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 p2 p1 p0] */
- d += (uint128_t)a3 * b[4]
- + (uint128_t)a4 * b[3];
- VERIFY_BITS(d, 114);
- /* [d 0 0 t4 t3 c t1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- c += (d & M) * R; d >>= 52;
- VERIFY_BITS(c, 115);
- VERIFY_BITS(d, 62);
- /* [d 0 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-
- /* [d 0 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[2] = c & M; c >>= 52;
- VERIFY_BITS(r[2], 52);
- VERIFY_BITS(c, 63);
- /* [d 0 0 0 t4 t3+c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- c += d * R + t3;
- VERIFY_BITS(c, 100);
- /* [t4 c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[3] = c & M; c >>= 52;
- VERIFY_BITS(r[3], 52);
- VERIFY_BITS(c, 48);
- /* [t4+c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- c += t4;
- VERIFY_BITS(c, 49);
- /* [c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[4] = c;
- VERIFY_BITS(r[4], 49);
- /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-}
-
-SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const uint64_t *a) {
- uint128_t c, d;
- uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
- int64_t t3, t4, tx, u0;
- const uint64_t M = 0xFFFFFFFFFFFFFULL, R = 0x1000003D10ULL;
-
- VERIFY_BITS(a[0], 56);
- VERIFY_BITS(a[1], 56);
- VERIFY_BITS(a[2], 56);
- VERIFY_BITS(a[3], 56);
- VERIFY_BITS(a[4], 52);
-
- /** [... a b c] is a shorthand for ... + a<<104 + b<<52 + c<<0 mod n.
- * px is a shorthand for sum(a[i]*a[x-i], i=0..x).
- * Note that [x 0 0 0 0 0] = [x*R].
- */
-
- d = (uint128_t)(a0*2) * a3
- + (uint128_t)(a1*2) * a2;
- VERIFY_BITS(d, 114);
- /* [d 0 0 0] = [p3 0 0 0] */
- c = (uint128_t)a4 * a4;
- VERIFY_BITS(c, 112);
- /* [c 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
- d += (c & M) * R; c >>= 52;
- VERIFY_BITS(d, 115);
- VERIFY_BITS(c, 60);
- /* [c 0 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
- t3 = d & M; d >>= 52;
- VERIFY_BITS(t3, 52);
- VERIFY_BITS(d, 63);
- /* [c 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
-
- a4 *= 2;
- d += (uint128_t)a0 * a4
- + (uint128_t)(a1*2) * a3
- + (uint128_t)a2 * a2;
- VERIFY_BITS(d, 115);
- /* [c 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
- d += c * R;
- VERIFY_BITS(d, 116);
- /* [d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
- t4 = d & M; d >>= 52;
- VERIFY_BITS(t4, 52);
- VERIFY_BITS(d, 64);
- /* [d t4 t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
- tx = (t4 >> 48); t4 &= (M >> 4);
- VERIFY_BITS(tx, 4);
- VERIFY_BITS(t4, 48);
- /* [d t4+(tx<<48) t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
-
- c = (uint128_t)a0 * a0;
- VERIFY_BITS(c, 112);
- /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 0 p4 p3 0 0 p0] */
- d += (uint128_t)a1 * a4
- + (uint128_t)(a2*2) * a3;
- VERIFY_BITS(d, 114);
- /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
- u0 = d & M; d >>= 52;
- VERIFY_BITS(u0, 52);
- VERIFY_BITS(d, 62);
- /* [d u0 t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
- /* [d 0 t4+(tx<<48)+(u0<<52) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
- u0 = (u0 << 4) | tx;
- VERIFY_BITS(u0, 56);
- /* [d 0 t4+(u0<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
- c += (uint128_t)u0 * (R >> 4);
- VERIFY_BITS(c, 113);
- /* [d 0 t4 t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
- r[0] = c & M; c >>= 52;
- VERIFY_BITS(r[0], 52);
- VERIFY_BITS(c, 61);
- /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 0 p0] */
-
- a0 *= 2;
- c += (uint128_t)a0 * a1;
- VERIFY_BITS(c, 114);
- /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 p1 p0] */
- d += (uint128_t)a2 * a4
- + (uint128_t)a3 * a3;
- VERIFY_BITS(d, 114);
- /* [d 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
- c += (d & M) * R; d >>= 52;
- VERIFY_BITS(c, 115);
- VERIFY_BITS(d, 62);
- /* [d 0 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
- r[1] = c & M; c >>= 52;
- VERIFY_BITS(r[1], 52);
- VERIFY_BITS(c, 63);
- /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
-
- c += (uint128_t)a0 * a2
- + (uint128_t)a1 * a1;
- VERIFY_BITS(c, 114);
- /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 p2 p1 p0] */
- d += (uint128_t)a3 * a4;
- VERIFY_BITS(d, 114);
- /* [d 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- c += (d & M) * R; d >>= 52;
- VERIFY_BITS(c, 115);
- VERIFY_BITS(d, 62);
- /* [d 0 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[2] = c & M; c >>= 52;
- VERIFY_BITS(r[2], 52);
- VERIFY_BITS(c, 63);
- /* [d 0 0 0 t4 t3+c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-
- c += d * R + t3;
- VERIFY_BITS(c, 100);
- /* [t4 c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[3] = c & M; c >>= 52;
- VERIFY_BITS(r[3], 52);
- VERIFY_BITS(c, 48);
- /* [t4+c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- c += t4;
- VERIFY_BITS(c, 49);
- /* [c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
- r[4] = c;
- VERIFY_BITS(r[4], 49);
- /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/field_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/field_impl.h
deleted file mode 100644
index 5127b279bc7f56b621042d9f79bfc200dd7086c7..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/field_impl.h
+++ /dev/null
@@ -1,315 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_FIELD_IMPL_H_
-#define _SECP256K1_FIELD_IMPL_H_
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#include "util.h"
-
-#if defined(USE_FIELD_10X26)
-#include "field_10x26_impl.h"
-#elif defined(USE_FIELD_5X52)
-#include "field_5x52_impl.h"
-#else
-#error "Please select field implementation"
-#endif
-
-SECP256K1_INLINE static int secp256k1_fe_equal(const secp256k1_fe *a, const secp256k1_fe *b) {
- secp256k1_fe na;
- secp256k1_fe_negate(&na, a, 1);
- secp256k1_fe_add(&na, b);
- return secp256k1_fe_normalizes_to_zero(&na);
-}
-
-SECP256K1_INLINE static int secp256k1_fe_equal_var(const secp256k1_fe *a, const secp256k1_fe *b) {
- secp256k1_fe na;
- secp256k1_fe_negate(&na, a, 1);
- secp256k1_fe_add(&na, b);
- return secp256k1_fe_normalizes_to_zero_var(&na);
-}
-
-static int secp256k1_fe_sqrt(secp256k1_fe *r, const secp256k1_fe *a) {
- /** Given that p is congruent to 3 mod 4, we can compute the square root of
- * a mod p as the (p+1)/4'th power of a.
- *
- * As (p+1)/4 is an even number, it will have the same result for a and for
- * (-a). Only one of these two numbers actually has a square root however,
- * so we test at the end by squaring and comparing to the input.
- * Also because (p+1)/4 is an even number, the computed square root is
- * itself always a square (a ** ((p+1)/4) is the square of a ** ((p+1)/8)).
- */
- secp256k1_fe x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
- int j;
-
- /** The binary representation of (p + 1)/4 has 3 blocks of 1s, with lengths in
- * { 2, 22, 223 }. Use an addition chain to calculate 2^n - 1 for each block:
- * 1, [2], 3, 6, 9, 11, [22], 44, 88, 176, 220, [223]
- */
-
- secp256k1_fe_sqr(&x2, a);
- secp256k1_fe_mul(&x2, &x2, a);
-
- secp256k1_fe_sqr(&x3, &x2);
- secp256k1_fe_mul(&x3, &x3, a);
-
- x6 = x3;
- for (j=0; j<3; j++) {
- secp256k1_fe_sqr(&x6, &x6);
- }
- secp256k1_fe_mul(&x6, &x6, &x3);
-
- x9 = x6;
- for (j=0; j<3; j++) {
- secp256k1_fe_sqr(&x9, &x9);
- }
- secp256k1_fe_mul(&x9, &x9, &x3);
-
- x11 = x9;
- for (j=0; j<2; j++) {
- secp256k1_fe_sqr(&x11, &x11);
- }
- secp256k1_fe_mul(&x11, &x11, &x2);
-
- x22 = x11;
- for (j=0; j<11; j++) {
- secp256k1_fe_sqr(&x22, &x22);
- }
- secp256k1_fe_mul(&x22, &x22, &x11);
-
- x44 = x22;
- for (j=0; j<22; j++) {
- secp256k1_fe_sqr(&x44, &x44);
- }
- secp256k1_fe_mul(&x44, &x44, &x22);
-
- x88 = x44;
- for (j=0; j<44; j++) {
- secp256k1_fe_sqr(&x88, &x88);
- }
- secp256k1_fe_mul(&x88, &x88, &x44);
-
- x176 = x88;
- for (j=0; j<88; j++) {
- secp256k1_fe_sqr(&x176, &x176);
- }
- secp256k1_fe_mul(&x176, &x176, &x88);
-
- x220 = x176;
- for (j=0; j<44; j++) {
- secp256k1_fe_sqr(&x220, &x220);
- }
- secp256k1_fe_mul(&x220, &x220, &x44);
-
- x223 = x220;
- for (j=0; j<3; j++) {
- secp256k1_fe_sqr(&x223, &x223);
- }
- secp256k1_fe_mul(&x223, &x223, &x3);
-
- /* The final result is then assembled using a sliding window over the blocks. */
-
- t1 = x223;
- for (j=0; j<23; j++) {
- secp256k1_fe_sqr(&t1, &t1);
- }
- secp256k1_fe_mul(&t1, &t1, &x22);
- for (j=0; j<6; j++) {
- secp256k1_fe_sqr(&t1, &t1);
- }
- secp256k1_fe_mul(&t1, &t1, &x2);
- secp256k1_fe_sqr(&t1, &t1);
- secp256k1_fe_sqr(r, &t1);
-
- /* Check that a square root was actually calculated */
-
- secp256k1_fe_sqr(&t1, r);
- return secp256k1_fe_equal(&t1, a);
-}
-
-static void secp256k1_fe_inv(secp256k1_fe *r, const secp256k1_fe *a) {
- secp256k1_fe x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
- int j;
-
- /** The binary representation of (p - 2) has 5 blocks of 1s, with lengths in
- * { 1, 2, 22, 223 }. Use an addition chain to calculate 2^n - 1 for each block:
- * [1], [2], 3, 6, 9, 11, [22], 44, 88, 176, 220, [223]
- */
-
- secp256k1_fe_sqr(&x2, a);
- secp256k1_fe_mul(&x2, &x2, a);
-
- secp256k1_fe_sqr(&x3, &x2);
- secp256k1_fe_mul(&x3, &x3, a);
-
- x6 = x3;
- for (j=0; j<3; j++) {
- secp256k1_fe_sqr(&x6, &x6);
- }
- secp256k1_fe_mul(&x6, &x6, &x3);
-
- x9 = x6;
- for (j=0; j<3; j++) {
- secp256k1_fe_sqr(&x9, &x9);
- }
- secp256k1_fe_mul(&x9, &x9, &x3);
-
- x11 = x9;
- for (j=0; j<2; j++) {
- secp256k1_fe_sqr(&x11, &x11);
- }
- secp256k1_fe_mul(&x11, &x11, &x2);
-
- x22 = x11;
- for (j=0; j<11; j++) {
- secp256k1_fe_sqr(&x22, &x22);
- }
- secp256k1_fe_mul(&x22, &x22, &x11);
-
- x44 = x22;
- for (j=0; j<22; j++) {
- secp256k1_fe_sqr(&x44, &x44);
- }
- secp256k1_fe_mul(&x44, &x44, &x22);
-
- x88 = x44;
- for (j=0; j<44; j++) {
- secp256k1_fe_sqr(&x88, &x88);
- }
- secp256k1_fe_mul(&x88, &x88, &x44);
-
- x176 = x88;
- for (j=0; j<88; j++) {
- secp256k1_fe_sqr(&x176, &x176);
- }
- secp256k1_fe_mul(&x176, &x176, &x88);
-
- x220 = x176;
- for (j=0; j<44; j++) {
- secp256k1_fe_sqr(&x220, &x220);
- }
- secp256k1_fe_mul(&x220, &x220, &x44);
-
- x223 = x220;
- for (j=0; j<3; j++) {
- secp256k1_fe_sqr(&x223, &x223);
- }
- secp256k1_fe_mul(&x223, &x223, &x3);
-
- /* The final result is then assembled using a sliding window over the blocks. */
-
- t1 = x223;
- for (j=0; j<23; j++) {
- secp256k1_fe_sqr(&t1, &t1);
- }
- secp256k1_fe_mul(&t1, &t1, &x22);
- for (j=0; j<5; j++) {
- secp256k1_fe_sqr(&t1, &t1);
- }
- secp256k1_fe_mul(&t1, &t1, a);
- for (j=0; j<3; j++) {
- secp256k1_fe_sqr(&t1, &t1);
- }
- secp256k1_fe_mul(&t1, &t1, &x2);
- for (j=0; j<2; j++) {
- secp256k1_fe_sqr(&t1, &t1);
- }
- secp256k1_fe_mul(r, a, &t1);
-}
-
-static void secp256k1_fe_inv_var(secp256k1_fe *r, const secp256k1_fe *a) {
-#if defined(USE_FIELD_INV_BUILTIN)
- secp256k1_fe_inv(r, a);
-#elif defined(USE_FIELD_INV_NUM)
- secp256k1_num n, m;
- static const secp256k1_fe negone = SECP256K1_FE_CONST(
- 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL,
- 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL, 0xFFFFFC2EUL
- );
- /* secp256k1 field prime, value p defined in "Standards for Efficient Cryptography" (SEC2) 2.7.1. */
- static const unsigned char prime[32] = {
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F
- };
- unsigned char b[32];
- int res;
- secp256k1_fe c = *a;
- secp256k1_fe_normalize_var(&c);
- secp256k1_fe_get_b32(b, &c);
- secp256k1_num_set_bin(&n, b, 32);
- secp256k1_num_set_bin(&m, prime, 32);
- secp256k1_num_mod_inverse(&n, &n, &m);
- secp256k1_num_get_bin(b, 32, &n);
- res = secp256k1_fe_set_b32(r, b);
- (void)res;
- VERIFY_CHECK(res);
- /* Verify the result is the (unique) valid inverse using non-GMP code. */
- secp256k1_fe_mul(&c, &c, r);
- secp256k1_fe_add(&c, &negone);
- CHECK(secp256k1_fe_normalizes_to_zero_var(&c));
-#else
-#error "Please select field inverse implementation"
-#endif
-}
-
-static void secp256k1_fe_inv_all_var(secp256k1_fe *r, const secp256k1_fe *a, size_t len) {
- secp256k1_fe u;
- size_t i;
- if (len < 1) {
- return;
- }
-
- VERIFY_CHECK((r + len <= a) || (a + len <= r));
-
- r[0] = a[0];
-
- i = 0;
- while (++i < len) {
- secp256k1_fe_mul(&r[i], &r[i - 1], &a[i]);
- }
-
- secp256k1_fe_inv_var(&u, &r[--i]);
-
- while (i > 0) {
- size_t j = i--;
- secp256k1_fe_mul(&r[j], &r[i], &u);
- secp256k1_fe_mul(&u, &u, &a[j]);
- }
-
- r[0] = u;
-}
-
-static int secp256k1_fe_is_quad_var(const secp256k1_fe *a) {
-#ifndef USE_NUM_NONE
- unsigned char b[32];
- secp256k1_num n;
- secp256k1_num m;
- /* secp256k1 field prime, value p defined in "Standards for Efficient Cryptography" (SEC2) 2.7.1. */
- static const unsigned char prime[32] = {
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F
- };
-
- secp256k1_fe c = *a;
- secp256k1_fe_normalize_var(&c);
- secp256k1_fe_get_b32(b, &c);
- secp256k1_num_set_bin(&n, b, 32);
- secp256k1_num_set_bin(&m, prime, 32);
- return secp256k1_num_jacobi(&n, &m) >= 0;
-#else
- secp256k1_fe r;
- return secp256k1_fe_sqrt(&r, a);
-#endif
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/gen_context.c op-geth/crypto/secp256k1/libsecp256k1/src/gen_context.c
deleted file mode 100644
index 1835fd491d16b7d8f4774327f25994a79ea1986a..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/gen_context.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014, 2015 Thomas Daede, Cory Fields *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#define USE_BASIC_CONFIG 1
-
-#include "basic-config.h"
-#include "include/secp256k1.h"
-#include "field_impl.h"
-#include "scalar_impl.h"
-#include "group_impl.h"
-#include "ecmult_gen_impl.h"
-
-static void default_error_callback_fn(const char* str, void* data) {
- (void)data;
- fprintf(stderr, "[libsecp256k1] internal consistency check failed: %s\n", str);
- abort();
-}
-
-static const secp256k1_callback default_error_callback = {
- default_error_callback_fn,
- NULL
-};
-
-int main(int argc, char **argv) {
- secp256k1_ecmult_gen_context ctx;
- int inner;
- int outer;
- FILE* fp;
-
- (void)argc;
- (void)argv;
-
- fp = fopen("src/ecmult_static_context.h","w");
- if (fp == NULL) {
- fprintf(stderr, "Could not open src/ecmult_static_context.h for writing!\n");
- return -1;
- }
-
- fprintf(fp, "#ifndef _SECP256K1_ECMULT_STATIC_CONTEXT_\n");
- fprintf(fp, "#define _SECP256K1_ECMULT_STATIC_CONTEXT_\n");
- fprintf(fp, "#include \"group.h\"\n");
- fprintf(fp, "#define SC SECP256K1_GE_STORAGE_CONST\n");
- fprintf(fp, "static const secp256k1_ge_storage secp256k1_ecmult_static_context[64][16] = {\n");
-
- secp256k1_ecmult_gen_context_init(&ctx);
- secp256k1_ecmult_gen_context_build(&ctx, &default_error_callback);
- for(outer = 0; outer != 64; outer++) {
- fprintf(fp,"{\n");
- for(inner = 0; inner != 16; inner++) {
- fprintf(fp," SC(%uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu, %uu)", SECP256K1_GE_STORAGE_CONST_GET((*ctx.prec)[outer][inner]));
- if (inner != 15) {
- fprintf(fp,",\n");
- } else {
- fprintf(fp,"\n");
- }
- }
- if (outer != 63) {
- fprintf(fp,"},\n");
- } else {
- fprintf(fp,"}\n");
- }
- }
- fprintf(fp,"};\n");
- secp256k1_ecmult_gen_context_clear(&ctx);
-
- fprintf(fp, "#undef SC\n");
- fprintf(fp, "#endif\n");
- fclose(fp);
-
- return 0;
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/group.h op-geth/crypto/secp256k1/libsecp256k1/src/group.h
deleted file mode 100644
index 4957b248fe6a608b8ae825b9b200b263415f36c4..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/group.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_GROUP_
-#define _SECP256K1_GROUP_
-
-#include "num.h"
-#include "field.h"
-
-/** A group element of the secp256k1 curve, in affine coordinates. */
-typedef struct {
- secp256k1_fe x;
- secp256k1_fe y;
- int infinity; /* whether this represents the point at infinity */
-} secp256k1_ge;
-
-#define SECP256K1_GE_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_CONST((i),(j),(k),(l),(m),(n),(o),(p)), 0}
-#define SECP256K1_GE_CONST_INFINITY {SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), 1}
-
-/** A group element of the secp256k1 curve, in jacobian coordinates. */
-typedef struct {
- secp256k1_fe x; /* actual X: x/z^2 */
- secp256k1_fe y; /* actual Y: y/z^3 */
- secp256k1_fe z;
- int infinity; /* whether this represents the point at infinity */
-} secp256k1_gej;
-
-#define SECP256K1_GEJ_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_CONST((i),(j),(k),(l),(m),(n),(o),(p)), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1), 0}
-#define SECP256K1_GEJ_CONST_INFINITY {SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 0), 1}
-
-typedef struct {
- secp256k1_fe_storage x;
- secp256k1_fe_storage y;
-} secp256k1_ge_storage;
-
-#define SECP256K1_GE_STORAGE_CONST(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {SECP256K1_FE_STORAGE_CONST((a),(b),(c),(d),(e),(f),(g),(h)), SECP256K1_FE_STORAGE_CONST((i),(j),(k),(l),(m),(n),(o),(p))}
-
-#define SECP256K1_GE_STORAGE_CONST_GET(t) SECP256K1_FE_STORAGE_CONST_GET(t.x), SECP256K1_FE_STORAGE_CONST_GET(t.y)
-
-/** Set a group element equal to the point with given X and Y coordinates */
-static void secp256k1_ge_set_xy(secp256k1_ge *r, const secp256k1_fe *x, const secp256k1_fe *y);
-
-/** Set a group element (affine) equal to the point with the given X coordinate
- * and a Y coordinate that is a quadratic residue modulo p. The return value
- * is true iff a coordinate with the given X coordinate exists.
- */
-static int secp256k1_ge_set_xquad(secp256k1_ge *r, const secp256k1_fe *x);
-
-/** Set a group element (affine) equal to the point with the given X coordinate, and given oddness
- * for Y. Return value indicates whether the result is valid. */
-static int secp256k1_ge_set_xo_var(secp256k1_ge *r, const secp256k1_fe *x, int odd);
-
-/** Check whether a group element is the point at infinity. */
-static int secp256k1_ge_is_infinity(const secp256k1_ge *a);
-
-/** Check whether a group element is valid (i.e., on the curve). */
-static int secp256k1_ge_is_valid_var(const secp256k1_ge *a);
-
-static void secp256k1_ge_neg(secp256k1_ge *r, const secp256k1_ge *a);
-
-/** Set a group element equal to another which is given in jacobian coordinates */
-static void secp256k1_ge_set_gej(secp256k1_ge *r, secp256k1_gej *a);
-
-/** Set a batch of group elements equal to the inputs given in jacobian coordinates */
-static void secp256k1_ge_set_all_gej_var(secp256k1_ge *r, const secp256k1_gej *a, size_t len, const secp256k1_callback *cb);
-
-/** Set a batch of group elements equal to the inputs given in jacobian
- * coordinates (with known z-ratios). zr must contain the known z-ratios such
- * that mul(a[i].z, zr[i+1]) == a[i+1].z. zr[0] is ignored. */
-static void secp256k1_ge_set_table_gej_var(secp256k1_ge *r, const secp256k1_gej *a, const secp256k1_fe *zr, size_t len);
-
-/** Bring a batch inputs given in jacobian coordinates (with known z-ratios) to
- * the same global z "denominator". zr must contain the known z-ratios such
- * that mul(a[i].z, zr[i+1]) == a[i+1].z. zr[0] is ignored. The x and y
- * coordinates of the result are stored in r, the common z coordinate is
- * stored in globalz. */
-static void secp256k1_ge_globalz_set_table_gej(size_t len, secp256k1_ge *r, secp256k1_fe *globalz, const secp256k1_gej *a, const secp256k1_fe *zr);
-
-/** Set a group element (jacobian) equal to the point at infinity. */
-static void secp256k1_gej_set_infinity(secp256k1_gej *r);
-
-/** Set a group element (jacobian) equal to another which is given in affine coordinates. */
-static void secp256k1_gej_set_ge(secp256k1_gej *r, const secp256k1_ge *a);
-
-/** Compare the X coordinate of a group element (jacobian). */
-static int secp256k1_gej_eq_x_var(const secp256k1_fe *x, const secp256k1_gej *a);
-
-/** Set r equal to the inverse of a (i.e., mirrored around the X axis) */
-static void secp256k1_gej_neg(secp256k1_gej *r, const secp256k1_gej *a);
-
-/** Check whether a group element is the point at infinity. */
-static int secp256k1_gej_is_infinity(const secp256k1_gej *a);
-
-/** Check whether a group element's y coordinate is a quadratic residue. */
-static int secp256k1_gej_has_quad_y_var(const secp256k1_gej *a);
-
-/** Set r equal to the double of a. If rzr is not-NULL, r->z = a->z * *rzr (where infinity means an implicit z = 0).
- * a may not be zero. Constant time. */
-static void secp256k1_gej_double_nonzero(secp256k1_gej *r, const secp256k1_gej *a, secp256k1_fe *rzr);
-
-/** Set r equal to the double of a. If rzr is not-NULL, r->z = a->z * *rzr (where infinity means an implicit z = 0). */
-static void secp256k1_gej_double_var(secp256k1_gej *r, const secp256k1_gej *a, secp256k1_fe *rzr);
-
-/** Set r equal to the sum of a and b. If rzr is non-NULL, r->z = a->z * *rzr (a cannot be infinity in that case). */
-static void secp256k1_gej_add_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_gej *b, secp256k1_fe *rzr);
-
-/** Set r equal to the sum of a and b (with b given in affine coordinates, and not infinity). */
-static void secp256k1_gej_add_ge(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b);
-
-/** Set r equal to the sum of a and b (with b given in affine coordinates). This is more efficient
- than secp256k1_gej_add_var. It is identical to secp256k1_gej_add_ge but without constant-time
- guarantee, and b is allowed to be infinity. If rzr is non-NULL, r->z = a->z * *rzr (a cannot be infinity in that case). */
-static void secp256k1_gej_add_ge_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b, secp256k1_fe *rzr);
-
-/** Set r equal to the sum of a and b (with the inverse of b's Z coordinate passed as bzinv). */
-static void secp256k1_gej_add_zinv_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b, const secp256k1_fe *bzinv);
-
-#ifdef USE_ENDOMORPHISM
-/** Set r to be equal to lambda times a, where lambda is chosen in a way such that this is very fast. */
-static void secp256k1_ge_mul_lambda(secp256k1_ge *r, const secp256k1_ge *a);
-#endif
-
-/** Clear a secp256k1_gej to prevent leaking sensitive information. */
-static void secp256k1_gej_clear(secp256k1_gej *r);
-
-/** Clear a secp256k1_ge to prevent leaking sensitive information. */
-static void secp256k1_ge_clear(secp256k1_ge *r);
-
-/** Convert a group element to the storage type. */
-static void secp256k1_ge_to_storage(secp256k1_ge_storage *r, const secp256k1_ge *a);
-
-/** Convert a group element back from the storage type. */
-static void secp256k1_ge_from_storage(secp256k1_ge *r, const secp256k1_ge_storage *a);
-
-/** If flag is true, set *r equal to *a; otherwise leave it. Constant-time. */
-static void secp256k1_ge_storage_cmov(secp256k1_ge_storage *r, const secp256k1_ge_storage *a, int flag);
-
-/** Rescale a jacobian point by b which must be non-zero. Constant-time. */
-static void secp256k1_gej_rescale(secp256k1_gej *r, const secp256k1_fe *b);
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/group_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/group_impl.h
deleted file mode 100644
index 7d723532ff3e12c1767540d019e35ede17a7c6c4..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/group_impl.h
+++ /dev/null
@@ -1,700 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_GROUP_IMPL_H_
-#define _SECP256K1_GROUP_IMPL_H_
-
-#include "num.h"
-#include "field.h"
-#include "group.h"
-
-/* These points can be generated in sage as follows:
- *
- * 0. Setup a worksheet with the following parameters.
- * b = 4 # whatever CURVE_B will be set to
- * F = FiniteField (0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
- * C = EllipticCurve ([F (0), F (b)])
- *
- * 1. Determine all the small orders available to you. (If there are
- * no satisfactory ones, go back and change b.)
- * print C.order().factor(limit=1000)
- *
- * 2. Choose an order as one of the prime factors listed in the above step.
- * (You can also multiply some to get a composite order, though the
- * tests will crash trying to invert scalars during signing.) We take a
- * random point and scale it to drop its order to the desired value.
- * There is some probability this won't work; just try again.
- * order = 199
- * P = C.random_point()
- * P = (int(P.order()) / int(order)) * P
- * assert(P.order() == order)
- *
- * 3. Print the values. You'll need to use a vim macro or something to
- * split the hex output into 4-byte chunks.
- * print "%x %x" % P.xy()
- */
-#if defined(EXHAUSTIVE_TEST_ORDER)
-# if EXHAUSTIVE_TEST_ORDER == 199
-const secp256k1_ge secp256k1_ge_const_g = SECP256K1_GE_CONST(
- 0xFA7CC9A7, 0x0737F2DB, 0xA749DD39, 0x2B4FB069,
- 0x3B017A7D, 0xA808C2F1, 0xFB12940C, 0x9EA66C18,
- 0x78AC123A, 0x5ED8AEF3, 0x8732BC91, 0x1F3A2868,
- 0x48DF246C, 0x808DAE72, 0xCFE52572, 0x7F0501ED
-);
-
-const int CURVE_B = 4;
-# elif EXHAUSTIVE_TEST_ORDER == 13
-const secp256k1_ge secp256k1_ge_const_g = SECP256K1_GE_CONST(
- 0xedc60018, 0xa51a786b, 0x2ea91f4d, 0x4c9416c0,
- 0x9de54c3b, 0xa1316554, 0x6cf4345c, 0x7277ef15,
- 0x54cb1b6b, 0xdc8c1273, 0x087844ea, 0x43f4603e,
- 0x0eaf9a43, 0xf6effe55, 0x939f806d, 0x37adf8ac
-);
-const int CURVE_B = 2;
-# else
-# error No known generator for the specified exhaustive test group order.
-# endif
-#else
-/** Generator for secp256k1, value 'g' defined in
- * "Standards for Efficient Cryptography" (SEC2) 2.7.1.
- */
-static const secp256k1_ge secp256k1_ge_const_g = SECP256K1_GE_CONST(
- 0x79BE667EUL, 0xF9DCBBACUL, 0x55A06295UL, 0xCE870B07UL,
- 0x029BFCDBUL, 0x2DCE28D9UL, 0x59F2815BUL, 0x16F81798UL,
- 0x483ADA77UL, 0x26A3C465UL, 0x5DA4FBFCUL, 0x0E1108A8UL,
- 0xFD17B448UL, 0xA6855419UL, 0x9C47D08FUL, 0xFB10D4B8UL
-);
-
-const int CURVE_B = 7;
-#endif
-
-static void secp256k1_ge_set_gej_zinv(secp256k1_ge *r, const secp256k1_gej *a, const secp256k1_fe *zi) {
- secp256k1_fe zi2;
- secp256k1_fe zi3;
- secp256k1_fe_sqr(&zi2, zi);
- secp256k1_fe_mul(&zi3, &zi2, zi);
- secp256k1_fe_mul(&r->x, &a->x, &zi2);
- secp256k1_fe_mul(&r->y, &a->y, &zi3);
- r->infinity = a->infinity;
-}
-
-static void secp256k1_ge_set_xy(secp256k1_ge *r, const secp256k1_fe *x, const secp256k1_fe *y) {
- r->infinity = 0;
- r->x = *x;
- r->y = *y;
-}
-
-static int secp256k1_ge_is_infinity(const secp256k1_ge *a) {
- return a->infinity;
-}
-
-static void secp256k1_ge_neg(secp256k1_ge *r, const secp256k1_ge *a) {
- *r = *a;
- secp256k1_fe_normalize_weak(&r->y);
- secp256k1_fe_negate(&r->y, &r->y, 1);
-}
-
-static void secp256k1_ge_set_gej(secp256k1_ge *r, secp256k1_gej *a) {
- secp256k1_fe z2, z3;
- r->infinity = a->infinity;
- secp256k1_fe_inv(&a->z, &a->z);
- secp256k1_fe_sqr(&z2, &a->z);
- secp256k1_fe_mul(&z3, &a->z, &z2);
- secp256k1_fe_mul(&a->x, &a->x, &z2);
- secp256k1_fe_mul(&a->y, &a->y, &z3);
- secp256k1_fe_set_int(&a->z, 1);
- r->x = a->x;
- r->y = a->y;
-}
-
-static void secp256k1_ge_set_gej_var(secp256k1_ge *r, secp256k1_gej *a) {
- secp256k1_fe z2, z3;
- r->infinity = a->infinity;
- if (a->infinity) {
- return;
- }
- secp256k1_fe_inv_var(&a->z, &a->z);
- secp256k1_fe_sqr(&z2, &a->z);
- secp256k1_fe_mul(&z3, &a->z, &z2);
- secp256k1_fe_mul(&a->x, &a->x, &z2);
- secp256k1_fe_mul(&a->y, &a->y, &z3);
- secp256k1_fe_set_int(&a->z, 1);
- r->x = a->x;
- r->y = a->y;
-}
-
-static void secp256k1_ge_set_all_gej_var(secp256k1_ge *r, const secp256k1_gej *a, size_t len, const secp256k1_callback *cb) {
- secp256k1_fe *az;
- secp256k1_fe *azi;
- size_t i;
- size_t count = 0;
- az = (secp256k1_fe *)checked_malloc(cb, sizeof(secp256k1_fe) * len);
- for (i = 0; i < len; i++) {
- if (!a[i].infinity) {
- az[count++] = a[i].z;
- }
- }
-
- azi = (secp256k1_fe *)checked_malloc(cb, sizeof(secp256k1_fe) * count);
- secp256k1_fe_inv_all_var(azi, az, count);
- free(az);
-
- count = 0;
- for (i = 0; i < len; i++) {
- r[i].infinity = a[i].infinity;
- if (!a[i].infinity) {
- secp256k1_ge_set_gej_zinv(&r[i], &a[i], &azi[count++]);
- }
- }
- free(azi);
-}
-
-static void secp256k1_ge_set_table_gej_var(secp256k1_ge *r, const secp256k1_gej *a, const secp256k1_fe *zr, size_t len) {
- size_t i = len - 1;
- secp256k1_fe zi;
-
- if (len > 0) {
- /* Compute the inverse of the last z coordinate, and use it to compute the last affine output. */
- secp256k1_fe_inv(&zi, &a[i].z);
- secp256k1_ge_set_gej_zinv(&r[i], &a[i], &zi);
-
- /* Work out way backwards, using the z-ratios to scale the x/y values. */
- while (i > 0) {
- secp256k1_fe_mul(&zi, &zi, &zr[i]);
- i--;
- secp256k1_ge_set_gej_zinv(&r[i], &a[i], &zi);
- }
- }
-}
-
-static void secp256k1_ge_globalz_set_table_gej(size_t len, secp256k1_ge *r, secp256k1_fe *globalz, const secp256k1_gej *a, const secp256k1_fe *zr) {
- size_t i = len - 1;
- secp256k1_fe zs;
-
- if (len > 0) {
- /* The z of the final point gives us the "global Z" for the table. */
- r[i].x = a[i].x;
- r[i].y = a[i].y;
- *globalz = a[i].z;
- r[i].infinity = 0;
- zs = zr[i];
-
- /* Work our way backwards, using the z-ratios to scale the x/y values. */
- while (i > 0) {
- if (i != len - 1) {
- secp256k1_fe_mul(&zs, &zs, &zr[i]);
- }
- i--;
- secp256k1_ge_set_gej_zinv(&r[i], &a[i], &zs);
- }
- }
-}
-
-static void secp256k1_gej_set_infinity(secp256k1_gej *r) {
- r->infinity = 1;
- secp256k1_fe_clear(&r->x);
- secp256k1_fe_clear(&r->y);
- secp256k1_fe_clear(&r->z);
-}
-
-static void secp256k1_gej_clear(secp256k1_gej *r) {
- r->infinity = 0;
- secp256k1_fe_clear(&r->x);
- secp256k1_fe_clear(&r->y);
- secp256k1_fe_clear(&r->z);
-}
-
-static void secp256k1_ge_clear(secp256k1_ge *r) {
- r->infinity = 0;
- secp256k1_fe_clear(&r->x);
- secp256k1_fe_clear(&r->y);
-}
-
-static int secp256k1_ge_set_xquad(secp256k1_ge *r, const secp256k1_fe *x) {
- secp256k1_fe x2, x3, c;
- r->x = *x;
- secp256k1_fe_sqr(&x2, x);
- secp256k1_fe_mul(&x3, x, &x2);
- r->infinity = 0;
- secp256k1_fe_set_int(&c, CURVE_B);
- secp256k1_fe_add(&c, &x3);
- return secp256k1_fe_sqrt(&r->y, &c);
-}
-
-static int secp256k1_ge_set_xo_var(secp256k1_ge *r, const secp256k1_fe *x, int odd) {
- if (!secp256k1_ge_set_xquad(r, x)) {
- return 0;
- }
- secp256k1_fe_normalize_var(&r->y);
- if (secp256k1_fe_is_odd(&r->y) != odd) {
- secp256k1_fe_negate(&r->y, &r->y, 1);
- }
- return 1;
-
-}
-
-static void secp256k1_gej_set_ge(secp256k1_gej *r, const secp256k1_ge *a) {
- r->infinity = a->infinity;
- r->x = a->x;
- r->y = a->y;
- secp256k1_fe_set_int(&r->z, 1);
-}
-
-static int secp256k1_gej_eq_x_var(const secp256k1_fe *x, const secp256k1_gej *a) {
- secp256k1_fe r, r2;
- VERIFY_CHECK(!a->infinity);
- secp256k1_fe_sqr(&r, &a->z); secp256k1_fe_mul(&r, &r, x);
- r2 = a->x; secp256k1_fe_normalize_weak(&r2);
- return secp256k1_fe_equal_var(&r, &r2);
-}
-
-static void secp256k1_gej_neg(secp256k1_gej *r, const secp256k1_gej *a) {
- r->infinity = a->infinity;
- r->x = a->x;
- r->y = a->y;
- r->z = a->z;
- secp256k1_fe_normalize_weak(&r->y);
- secp256k1_fe_negate(&r->y, &r->y, 1);
-}
-
-static int secp256k1_gej_is_infinity(const secp256k1_gej *a) {
- return a->infinity;
-}
-
-static int secp256k1_gej_is_valid_var(const secp256k1_gej *a) {
- secp256k1_fe y2, x3, z2, z6;
- if (a->infinity) {
- return 0;
- }
- /** y^2 = x^3 + 7
- * (Y/Z^3)^2 = (X/Z^2)^3 + 7
- * Y^2 / Z^6 = X^3 / Z^6 + 7
- * Y^2 = X^3 + 7*Z^6
- */
- secp256k1_fe_sqr(&y2, &a->y);
- secp256k1_fe_sqr(&x3, &a->x); secp256k1_fe_mul(&x3, &x3, &a->x);
- secp256k1_fe_sqr(&z2, &a->z);
- secp256k1_fe_sqr(&z6, &z2); secp256k1_fe_mul(&z6, &z6, &z2);
- secp256k1_fe_mul_int(&z6, CURVE_B);
- secp256k1_fe_add(&x3, &z6);
- secp256k1_fe_normalize_weak(&x3);
- return secp256k1_fe_equal_var(&y2, &x3);
-}
-
-static int secp256k1_ge_is_valid_var(const secp256k1_ge *a) {
- secp256k1_fe y2, x3, c;
- if (a->infinity) {
- return 0;
- }
- /* y^2 = x^3 + 7 */
- secp256k1_fe_sqr(&y2, &a->y);
- secp256k1_fe_sqr(&x3, &a->x); secp256k1_fe_mul(&x3, &x3, &a->x);
- secp256k1_fe_set_int(&c, CURVE_B);
- secp256k1_fe_add(&x3, &c);
- secp256k1_fe_normalize_weak(&x3);
- return secp256k1_fe_equal_var(&y2, &x3);
-}
-
-static void secp256k1_gej_double_var(secp256k1_gej *r, const secp256k1_gej *a, secp256k1_fe *rzr) {
- /* Operations: 3 mul, 4 sqr, 0 normalize, 12 mul_int/add/negate.
- *
- * Note that there is an implementation described at
- * https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#doubling-dbl-2009-l
- * which trades a multiply for a square, but in practice this is actually slower,
- * mainly because it requires more normalizations.
- */
- secp256k1_fe t1,t2,t3,t4;
- /** For secp256k1, 2Q is infinity if and only if Q is infinity. This is because if 2Q = infinity,
- * Q must equal -Q, or that Q.y == -(Q.y), or Q.y is 0. For a point on y^2 = x^3 + 7 to have
- * y=0, x^3 must be -7 mod p. However, -7 has no cube root mod p.
- *
- * Having said this, if this function receives a point on a sextic twist, e.g. by
- * a fault attack, it is possible for y to be 0. This happens for y^2 = x^3 + 6,
- * since -6 does have a cube root mod p. For this point, this function will not set
- * the infinity flag even though the point doubles to infinity, and the result
- * point will be gibberish (z = 0 but infinity = 0).
- */
- r->infinity = a->infinity;
- if (r->infinity) {
- if (rzr != NULL) {
- secp256k1_fe_set_int(rzr, 1);
- }
- return;
- }
-
- if (rzr != NULL) {
- *rzr = a->y;
- secp256k1_fe_normalize_weak(rzr);
- secp256k1_fe_mul_int(rzr, 2);
- }
-
- secp256k1_fe_mul(&r->z, &a->z, &a->y);
- secp256k1_fe_mul_int(&r->z, 2); /* Z' = 2*Y*Z (2) */
- secp256k1_fe_sqr(&t1, &a->x);
- secp256k1_fe_mul_int(&t1, 3); /* T1 = 3*X^2 (3) */
- secp256k1_fe_sqr(&t2, &t1); /* T2 = 9*X^4 (1) */
- secp256k1_fe_sqr(&t3, &a->y);
- secp256k1_fe_mul_int(&t3, 2); /* T3 = 2*Y^2 (2) */
- secp256k1_fe_sqr(&t4, &t3);
- secp256k1_fe_mul_int(&t4, 2); /* T4 = 8*Y^4 (2) */
- secp256k1_fe_mul(&t3, &t3, &a->x); /* T3 = 2*X*Y^2 (1) */
- r->x = t3;
- secp256k1_fe_mul_int(&r->x, 4); /* X' = 8*X*Y^2 (4) */
- secp256k1_fe_negate(&r->x, &r->x, 4); /* X' = -8*X*Y^2 (5) */
- secp256k1_fe_add(&r->x, &t2); /* X' = 9*X^4 - 8*X*Y^2 (6) */
- secp256k1_fe_negate(&t2, &t2, 1); /* T2 = -9*X^4 (2) */
- secp256k1_fe_mul_int(&t3, 6); /* T3 = 12*X*Y^2 (6) */
- secp256k1_fe_add(&t3, &t2); /* T3 = 12*X*Y^2 - 9*X^4 (8) */
- secp256k1_fe_mul(&r->y, &t1, &t3); /* Y' = 36*X^3*Y^2 - 27*X^6 (1) */
- secp256k1_fe_negate(&t2, &t4, 2); /* T2 = -8*Y^4 (3) */
- secp256k1_fe_add(&r->y, &t2); /* Y' = 36*X^3*Y^2 - 27*X^6 - 8*Y^4 (4) */
-}
-
-static SECP256K1_INLINE void secp256k1_gej_double_nonzero(secp256k1_gej *r, const secp256k1_gej *a, secp256k1_fe *rzr) {
- VERIFY_CHECK(!secp256k1_gej_is_infinity(a));
- secp256k1_gej_double_var(r, a, rzr);
-}
-
-static void secp256k1_gej_add_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_gej *b, secp256k1_fe *rzr) {
- /* Operations: 12 mul, 4 sqr, 2 normalize, 12 mul_int/add/negate */
- secp256k1_fe z22, z12, u1, u2, s1, s2, h, i, i2, h2, h3, t;
-
- if (a->infinity) {
- VERIFY_CHECK(rzr == NULL);
- *r = *b;
- return;
- }
-
- if (b->infinity) {
- if (rzr != NULL) {
- secp256k1_fe_set_int(rzr, 1);
- }
- *r = *a;
- return;
- }
-
- r->infinity = 0;
- secp256k1_fe_sqr(&z22, &b->z);
- secp256k1_fe_sqr(&z12, &a->z);
- secp256k1_fe_mul(&u1, &a->x, &z22);
- secp256k1_fe_mul(&u2, &b->x, &z12);
- secp256k1_fe_mul(&s1, &a->y, &z22); secp256k1_fe_mul(&s1, &s1, &b->z);
- secp256k1_fe_mul(&s2, &b->y, &z12); secp256k1_fe_mul(&s2, &s2, &a->z);
- secp256k1_fe_negate(&h, &u1, 1); secp256k1_fe_add(&h, &u2);
- secp256k1_fe_negate(&i, &s1, 1); secp256k1_fe_add(&i, &s2);
- if (secp256k1_fe_normalizes_to_zero_var(&h)) {
- if (secp256k1_fe_normalizes_to_zero_var(&i)) {
- secp256k1_gej_double_var(r, a, rzr);
- } else {
- if (rzr != NULL) {
- secp256k1_fe_set_int(rzr, 0);
- }
- r->infinity = 1;
- }
- return;
- }
- secp256k1_fe_sqr(&i2, &i);
- secp256k1_fe_sqr(&h2, &h);
- secp256k1_fe_mul(&h3, &h, &h2);
- secp256k1_fe_mul(&h, &h, &b->z);
- if (rzr != NULL) {
- *rzr = h;
- }
- secp256k1_fe_mul(&r->z, &a->z, &h);
- secp256k1_fe_mul(&t, &u1, &h2);
- r->x = t; secp256k1_fe_mul_int(&r->x, 2); secp256k1_fe_add(&r->x, &h3); secp256k1_fe_negate(&r->x, &r->x, 3); secp256k1_fe_add(&r->x, &i2);
- secp256k1_fe_negate(&r->y, &r->x, 5); secp256k1_fe_add(&r->y, &t); secp256k1_fe_mul(&r->y, &r->y, &i);
- secp256k1_fe_mul(&h3, &h3, &s1); secp256k1_fe_negate(&h3, &h3, 1);
- secp256k1_fe_add(&r->y, &h3);
-}
-
-static void secp256k1_gej_add_ge_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b, secp256k1_fe *rzr) {
- /* 8 mul, 3 sqr, 4 normalize, 12 mul_int/add/negate */
- secp256k1_fe z12, u1, u2, s1, s2, h, i, i2, h2, h3, t;
- if (a->infinity) {
- VERIFY_CHECK(rzr == NULL);
- secp256k1_gej_set_ge(r, b);
- return;
- }
- if (b->infinity) {
- if (rzr != NULL) {
- secp256k1_fe_set_int(rzr, 1);
- }
- *r = *a;
- return;
- }
- r->infinity = 0;
-
- secp256k1_fe_sqr(&z12, &a->z);
- u1 = a->x; secp256k1_fe_normalize_weak(&u1);
- secp256k1_fe_mul(&u2, &b->x, &z12);
- s1 = a->y; secp256k1_fe_normalize_weak(&s1);
- secp256k1_fe_mul(&s2, &b->y, &z12); secp256k1_fe_mul(&s2, &s2, &a->z);
- secp256k1_fe_negate(&h, &u1, 1); secp256k1_fe_add(&h, &u2);
- secp256k1_fe_negate(&i, &s1, 1); secp256k1_fe_add(&i, &s2);
- if (secp256k1_fe_normalizes_to_zero_var(&h)) {
- if (secp256k1_fe_normalizes_to_zero_var(&i)) {
- secp256k1_gej_double_var(r, a, rzr);
- } else {
- if (rzr != NULL) {
- secp256k1_fe_set_int(rzr, 0);
- }
- r->infinity = 1;
- }
- return;
- }
- secp256k1_fe_sqr(&i2, &i);
- secp256k1_fe_sqr(&h2, &h);
- secp256k1_fe_mul(&h3, &h, &h2);
- if (rzr != NULL) {
- *rzr = h;
- }
- secp256k1_fe_mul(&r->z, &a->z, &h);
- secp256k1_fe_mul(&t, &u1, &h2);
- r->x = t; secp256k1_fe_mul_int(&r->x, 2); secp256k1_fe_add(&r->x, &h3); secp256k1_fe_negate(&r->x, &r->x, 3); secp256k1_fe_add(&r->x, &i2);
- secp256k1_fe_negate(&r->y, &r->x, 5); secp256k1_fe_add(&r->y, &t); secp256k1_fe_mul(&r->y, &r->y, &i);
- secp256k1_fe_mul(&h3, &h3, &s1); secp256k1_fe_negate(&h3, &h3, 1);
- secp256k1_fe_add(&r->y, &h3);
-}
-
-static void secp256k1_gej_add_zinv_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b, const secp256k1_fe *bzinv) {
- /* 9 mul, 3 sqr, 4 normalize, 12 mul_int/add/negate */
- secp256k1_fe az, z12, u1, u2, s1, s2, h, i, i2, h2, h3, t;
-
- if (b->infinity) {
- *r = *a;
- return;
- }
- if (a->infinity) {
- secp256k1_fe bzinv2, bzinv3;
- r->infinity = b->infinity;
- secp256k1_fe_sqr(&bzinv2, bzinv);
- secp256k1_fe_mul(&bzinv3, &bzinv2, bzinv);
- secp256k1_fe_mul(&r->x, &b->x, &bzinv2);
- secp256k1_fe_mul(&r->y, &b->y, &bzinv3);
- secp256k1_fe_set_int(&r->z, 1);
- return;
- }
- r->infinity = 0;
-
- /** We need to calculate (rx,ry,rz) = (ax,ay,az) + (bx,by,1/bzinv). Due to
- * secp256k1's isomorphism we can multiply the Z coordinates on both sides
- * by bzinv, and get: (rx,ry,rz*bzinv) = (ax,ay,az*bzinv) + (bx,by,1).
- * This means that (rx,ry,rz) can be calculated as
- * (ax,ay,az*bzinv) + (bx,by,1), when not applying the bzinv factor to rz.
- * The variable az below holds the modified Z coordinate for a, which is used
- * for the computation of rx and ry, but not for rz.
- */
- secp256k1_fe_mul(&az, &a->z, bzinv);
-
- secp256k1_fe_sqr(&z12, &az);
- u1 = a->x; secp256k1_fe_normalize_weak(&u1);
- secp256k1_fe_mul(&u2, &b->x, &z12);
- s1 = a->y; secp256k1_fe_normalize_weak(&s1);
- secp256k1_fe_mul(&s2, &b->y, &z12); secp256k1_fe_mul(&s2, &s2, &az);
- secp256k1_fe_negate(&h, &u1, 1); secp256k1_fe_add(&h, &u2);
- secp256k1_fe_negate(&i, &s1, 1); secp256k1_fe_add(&i, &s2);
- if (secp256k1_fe_normalizes_to_zero_var(&h)) {
- if (secp256k1_fe_normalizes_to_zero_var(&i)) {
- secp256k1_gej_double_var(r, a, NULL);
- } else {
- r->infinity = 1;
- }
- return;
- }
- secp256k1_fe_sqr(&i2, &i);
- secp256k1_fe_sqr(&h2, &h);
- secp256k1_fe_mul(&h3, &h, &h2);
- r->z = a->z; secp256k1_fe_mul(&r->z, &r->z, &h);
- secp256k1_fe_mul(&t, &u1, &h2);
- r->x = t; secp256k1_fe_mul_int(&r->x, 2); secp256k1_fe_add(&r->x, &h3); secp256k1_fe_negate(&r->x, &r->x, 3); secp256k1_fe_add(&r->x, &i2);
- secp256k1_fe_negate(&r->y, &r->x, 5); secp256k1_fe_add(&r->y, &t); secp256k1_fe_mul(&r->y, &r->y, &i);
- secp256k1_fe_mul(&h3, &h3, &s1); secp256k1_fe_negate(&h3, &h3, 1);
- secp256k1_fe_add(&r->y, &h3);
-}
-
-
-static void secp256k1_gej_add_ge(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b) {
- /* Operations: 7 mul, 5 sqr, 4 normalize, 21 mul_int/add/negate/cmov */
- static const secp256k1_fe fe_1 = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1);
- secp256k1_fe zz, u1, u2, s1, s2, t, tt, m, n, q, rr;
- secp256k1_fe m_alt, rr_alt;
- int infinity, degenerate;
- VERIFY_CHECK(!b->infinity);
- VERIFY_CHECK(a->infinity == 0 || a->infinity == 1);
-
- /** In:
- * Eric Brier and Marc Joye, Weierstrass Elliptic Curves and Side-Channel Attacks.
- * In D. Naccache and P. Paillier, Eds., Public Key Cryptography, vol. 2274 of Lecture Notes in Computer Science, pages 335-345. Springer-Verlag, 2002.
- * we find as solution for a unified addition/doubling formula:
- * lambda = ((x1 + x2)^2 - x1 * x2 + a) / (y1 + y2), with a = 0 for secp256k1's curve equation.
- * x3 = lambda^2 - (x1 + x2)
- * 2*y3 = lambda * (x1 + x2 - 2 * x3) - (y1 + y2).
- *
- * Substituting x_i = Xi / Zi^2 and yi = Yi / Zi^3, for i=1,2,3, gives:
- * U1 = X1*Z2^2, U2 = X2*Z1^2
- * S1 = Y1*Z2^3, S2 = Y2*Z1^3
- * Z = Z1*Z2
- * T = U1+U2
- * M = S1+S2
- * Q = T*M^2
- * R = T^2-U1*U2
- * X3 = 4*(R^2-Q)
- * Y3 = 4*(R*(3*Q-2*R^2)-M^4)
- * Z3 = 2*M*Z
- * (Note that the paper uses xi = Xi / Zi and yi = Yi / Zi instead.)
- *
- * This formula has the benefit of being the same for both addition
- * of distinct points and doubling. However, it breaks down in the
- * case that either point is infinity, or that y1 = -y2. We handle
- * these cases in the following ways:
- *
- * - If b is infinity we simply bail by means of a VERIFY_CHECK.
- *
- * - If a is infinity, we detect this, and at the end of the
- * computation replace the result (which will be meaningless,
- * but we compute to be constant-time) with b.x : b.y : 1.
- *
- * - If a = -b, we have y1 = -y2, which is a degenerate case.
- * But here the answer is infinity, so we simply set the
- * infinity flag of the result, overriding the computed values
- * without even needing to cmov.
- *
- * - If y1 = -y2 but x1 != x2, which does occur thanks to certain
- * properties of our curve (specifically, 1 has nontrivial cube
- * roots in our field, and the curve equation has no x coefficient)
- * then the answer is not infinity but also not given by the above
- * equation. In this case, we cmov in place an alternate expression
- * for lambda. Specifically (y1 - y2)/(x1 - x2). Where both these
- * expressions for lambda are defined, they are equal, and can be
- * obtained from each other by multiplication by (y1 + y2)/(y1 + y2)
- * then substitution of x^3 + 7 for y^2 (using the curve equation).
- * For all pairs of nonzero points (a, b) at least one is defined,
- * so this covers everything.
- */
-
- secp256k1_fe_sqr(&zz, &a->z); /* z = Z1^2 */
- u1 = a->x; secp256k1_fe_normalize_weak(&u1); /* u1 = U1 = X1*Z2^2 (1) */
- secp256k1_fe_mul(&u2, &b->x, &zz); /* u2 = U2 = X2*Z1^2 (1) */
- s1 = a->y; secp256k1_fe_normalize_weak(&s1); /* s1 = S1 = Y1*Z2^3 (1) */
- secp256k1_fe_mul(&s2, &b->y, &zz); /* s2 = Y2*Z1^2 (1) */
- secp256k1_fe_mul(&s2, &s2, &a->z); /* s2 = S2 = Y2*Z1^3 (1) */
- t = u1; secp256k1_fe_add(&t, &u2); /* t = T = U1+U2 (2) */
- m = s1; secp256k1_fe_add(&m, &s2); /* m = M = S1+S2 (2) */
- secp256k1_fe_sqr(&rr, &t); /* rr = T^2 (1) */
- secp256k1_fe_negate(&m_alt, &u2, 1); /* Malt = -X2*Z1^2 */
- secp256k1_fe_mul(&tt, &u1, &m_alt); /* tt = -U1*U2 (2) */
- secp256k1_fe_add(&rr, &tt); /* rr = R = T^2-U1*U2 (3) */
- /** If lambda = R/M = 0/0 we have a problem (except in the "trivial"
- * case that Z = z1z2 = 0, and this is special-cased later on). */
- degenerate = secp256k1_fe_normalizes_to_zero(&m) &
- secp256k1_fe_normalizes_to_zero(&rr);
- /* This only occurs when y1 == -y2 and x1^3 == x2^3, but x1 != x2.
- * This means either x1 == beta*x2 or beta*x1 == x2, where beta is
- * a nontrivial cube root of one. In either case, an alternate
- * non-indeterminate expression for lambda is (y1 - y2)/(x1 - x2),
- * so we set R/M equal to this. */
- rr_alt = s1;
- secp256k1_fe_mul_int(&rr_alt, 2); /* rr = Y1*Z2^3 - Y2*Z1^3 (2) */
- secp256k1_fe_add(&m_alt, &u1); /* Malt = X1*Z2^2 - X2*Z1^2 */
-
- secp256k1_fe_cmov(&rr_alt, &rr, !degenerate);
- secp256k1_fe_cmov(&m_alt, &m, !degenerate);
- /* Now Ralt / Malt = lambda and is guaranteed not to be 0/0.
- * From here on out Ralt and Malt represent the numerator
- * and denominator of lambda; R and M represent the explicit
- * expressions x1^2 + x2^2 + x1x2 and y1 + y2. */
- secp256k1_fe_sqr(&n, &m_alt); /* n = Malt^2 (1) */
- secp256k1_fe_mul(&q, &n, &t); /* q = Q = T*Malt^2 (1) */
- /* These two lines use the observation that either M == Malt or M == 0,
- * so M^3 * Malt is either Malt^4 (which is computed by squaring), or
- * zero (which is "computed" by cmov). So the cost is one squaring
- * versus two multiplications. */
- secp256k1_fe_sqr(&n, &n);
- secp256k1_fe_cmov(&n, &m, degenerate); /* n = M^3 * Malt (2) */
- secp256k1_fe_sqr(&t, &rr_alt); /* t = Ralt^2 (1) */
- secp256k1_fe_mul(&r->z, &a->z, &m_alt); /* r->z = Malt*Z (1) */
- infinity = secp256k1_fe_normalizes_to_zero(&r->z) * (1 - a->infinity);
- secp256k1_fe_mul_int(&r->z, 2); /* r->z = Z3 = 2*Malt*Z (2) */
- secp256k1_fe_negate(&q, &q, 1); /* q = -Q (2) */
- secp256k1_fe_add(&t, &q); /* t = Ralt^2-Q (3) */
- secp256k1_fe_normalize_weak(&t);
- r->x = t; /* r->x = Ralt^2-Q (1) */
- secp256k1_fe_mul_int(&t, 2); /* t = 2*x3 (2) */
- secp256k1_fe_add(&t, &q); /* t = 2*x3 - Q: (4) */
- secp256k1_fe_mul(&t, &t, &rr_alt); /* t = Ralt*(2*x3 - Q) (1) */
- secp256k1_fe_add(&t, &n); /* t = Ralt*(2*x3 - Q) + M^3*Malt (3) */
- secp256k1_fe_negate(&r->y, &t, 3); /* r->y = Ralt*(Q - 2x3) - M^3*Malt (4) */
- secp256k1_fe_normalize_weak(&r->y);
- secp256k1_fe_mul_int(&r->x, 4); /* r->x = X3 = 4*(Ralt^2-Q) */
- secp256k1_fe_mul_int(&r->y, 4); /* r->y = Y3 = 4*Ralt*(Q - 2x3) - 4*M^3*Malt (4) */
-
- /** In case a->infinity == 1, replace r with (b->x, b->y, 1). */
- secp256k1_fe_cmov(&r->x, &b->x, a->infinity);
- secp256k1_fe_cmov(&r->y, &b->y, a->infinity);
- secp256k1_fe_cmov(&r->z, &fe_1, a->infinity);
- r->infinity = infinity;
-}
-
-static void secp256k1_gej_rescale(secp256k1_gej *r, const secp256k1_fe *s) {
- /* Operations: 4 mul, 1 sqr */
- secp256k1_fe zz;
- VERIFY_CHECK(!secp256k1_fe_is_zero(s));
- secp256k1_fe_sqr(&zz, s);
- secp256k1_fe_mul(&r->x, &r->x, &zz); /* r->x *= s^2 */
- secp256k1_fe_mul(&r->y, &r->y, &zz);
- secp256k1_fe_mul(&r->y, &r->y, s); /* r->y *= s^3 */
- secp256k1_fe_mul(&r->z, &r->z, s); /* r->z *= s */
-}
-
-static void secp256k1_ge_to_storage(secp256k1_ge_storage *r, const secp256k1_ge *a) {
- secp256k1_fe x, y;
- VERIFY_CHECK(!a->infinity);
- x = a->x;
- secp256k1_fe_normalize(&x);
- y = a->y;
- secp256k1_fe_normalize(&y);
- secp256k1_fe_to_storage(&r->x, &x);
- secp256k1_fe_to_storage(&r->y, &y);
-}
-
-static void secp256k1_ge_from_storage(secp256k1_ge *r, const secp256k1_ge_storage *a) {
- secp256k1_fe_from_storage(&r->x, &a->x);
- secp256k1_fe_from_storage(&r->y, &a->y);
- r->infinity = 0;
-}
-
-static SECP256K1_INLINE void secp256k1_ge_storage_cmov(secp256k1_ge_storage *r, const secp256k1_ge_storage *a, int flag) {
- secp256k1_fe_storage_cmov(&r->x, &a->x, flag);
- secp256k1_fe_storage_cmov(&r->y, &a->y, flag);
-}
-
-#ifdef USE_ENDOMORPHISM
-static void secp256k1_ge_mul_lambda(secp256k1_ge *r, const secp256k1_ge *a) {
- static const secp256k1_fe beta = SECP256K1_FE_CONST(
- 0x7ae96a2bul, 0x657c0710ul, 0x6e64479eul, 0xac3434e9ul,
- 0x9cf04975ul, 0x12f58995ul, 0xc1396c28ul, 0x719501eeul
- );
- *r = *a;
- secp256k1_fe_mul(&r->x, &r->x, &beta);
-}
-#endif
-
-static int secp256k1_gej_has_quad_y_var(const secp256k1_gej *a) {
- secp256k1_fe yz;
-
- if (a->infinity) {
- return 0;
- }
-
- /* We rely on the fact that the Jacobi symbol of 1 / a->z^3 is the same as
- * that of a->z. Thus a->y / a->z^3 is a quadratic residue iff a->y * a->z
- is */
- secp256k1_fe_mul(&yz, &a->y, &a->z);
- return secp256k1_fe_is_quad_var(&yz);
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/hash.h op-geth/crypto/secp256k1/libsecp256k1/src/hash.h
deleted file mode 100644
index fca98cab9f8315bd4fa5c165d9f8e2f16dc2a493..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/hash.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_HASH_
-#define _SECP256K1_HASH_
-
-#include <stdlib.h>
-#include <stdint.h>
-
-typedef struct {
- uint32_t s[8];
- uint32_t buf[16]; /* In big endian */
- size_t bytes;
-} secp256k1_sha256_t;
-
-static void secp256k1_sha256_initialize(secp256k1_sha256_t *hash);
-static void secp256k1_sha256_write(secp256k1_sha256_t *hash, const unsigned char *data, size_t size);
-static void secp256k1_sha256_finalize(secp256k1_sha256_t *hash, unsigned char *out32);
-
-typedef struct {
- secp256k1_sha256_t inner, outer;
-} secp256k1_hmac_sha256_t;
-
-static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256_t *hash, const unsigned char *key, size_t size);
-static void secp256k1_hmac_sha256_write(secp256k1_hmac_sha256_t *hash, const unsigned char *data, size_t size);
-static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256_t *hash, unsigned char *out32);
-
-typedef struct {
- unsigned char v[32];
- unsigned char k[32];
- int retry;
-} secp256k1_rfc6979_hmac_sha256_t;
-
-static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen);
-static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256_t *rng, unsigned char *out, size_t outlen);
-static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256_t *rng);
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/hash_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/hash_impl.h
deleted file mode 100644
index b47e65f830a906fc0eb9ff7939d62966823202b1..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/hash_impl.h
+++ /dev/null
@@ -1,281 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_HASH_IMPL_H_
-#define _SECP256K1_HASH_IMPL_H_
-
-#include "hash.h"
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-
-#define Ch(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
-#define Maj(x,y,z) (((x) & (y)) | ((z) & ((x) | (y))))
-#define Sigma0(x) (((x) >> 2 | (x) << 30) ^ ((x) >> 13 | (x) << 19) ^ ((x) >> 22 | (x) << 10))
-#define Sigma1(x) (((x) >> 6 | (x) << 26) ^ ((x) >> 11 | (x) << 21) ^ ((x) >> 25 | (x) << 7))
-#define sigma0(x) (((x) >> 7 | (x) << 25) ^ ((x) >> 18 | (x) << 14) ^ ((x) >> 3))
-#define sigma1(x) (((x) >> 17 | (x) << 15) ^ ((x) >> 19 | (x) << 13) ^ ((x) >> 10))
-
-#define Round(a,b,c,d,e,f,g,h,k,w) do { \
- uint32_t t1 = (h) + Sigma1(e) + Ch((e), (f), (g)) + (k) + (w); \
- uint32_t t2 = Sigma0(a) + Maj((a), (b), (c)); \
- (d) += t1; \
- (h) = t1 + t2; \
-} while(0)
-
-#ifdef WORDS_BIGENDIAN
-#define BE32(x) (x)
-#else
-#define BE32(p) ((((p) & 0xFF) << 24) | (((p) & 0xFF00) << 8) | (((p) & 0xFF0000) >> 8) | (((p) & 0xFF000000) >> 24))
-#endif
-
-static void secp256k1_sha256_initialize(secp256k1_sha256_t *hash) {
- hash->s[0] = 0x6a09e667ul;
- hash->s[1] = 0xbb67ae85ul;
- hash->s[2] = 0x3c6ef372ul;
- hash->s[3] = 0xa54ff53aul;
- hash->s[4] = 0x510e527ful;
- hash->s[5] = 0x9b05688cul;
- hash->s[6] = 0x1f83d9abul;
- hash->s[7] = 0x5be0cd19ul;
- hash->bytes = 0;
-}
-
-/** Perform one SHA-256 transformation, processing 16 big endian 32-bit words. */
-static void secp256k1_sha256_transform(uint32_t* s, const uint32_t* chunk) {
- uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
- uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
-
- Round(a, b, c, d, e, f, g, h, 0x428a2f98, w0 = BE32(chunk[0]));
- Round(h, a, b, c, d, e, f, g, 0x71374491, w1 = BE32(chunk[1]));
- Round(g, h, a, b, c, d, e, f, 0xb5c0fbcf, w2 = BE32(chunk[2]));
- Round(f, g, h, a, b, c, d, e, 0xe9b5dba5, w3 = BE32(chunk[3]));
- Round(e, f, g, h, a, b, c, d, 0x3956c25b, w4 = BE32(chunk[4]));
- Round(d, e, f, g, h, a, b, c, 0x59f111f1, w5 = BE32(chunk[5]));
- Round(c, d, e, f, g, h, a, b, 0x923f82a4, w6 = BE32(chunk[6]));
- Round(b, c, d, e, f, g, h, a, 0xab1c5ed5, w7 = BE32(chunk[7]));
- Round(a, b, c, d, e, f, g, h, 0xd807aa98, w8 = BE32(chunk[8]));
- Round(h, a, b, c, d, e, f, g, 0x12835b01, w9 = BE32(chunk[9]));
- Round(g, h, a, b, c, d, e, f, 0x243185be, w10 = BE32(chunk[10]));
- Round(f, g, h, a, b, c, d, e, 0x550c7dc3, w11 = BE32(chunk[11]));
- Round(e, f, g, h, a, b, c, d, 0x72be5d74, w12 = BE32(chunk[12]));
- Round(d, e, f, g, h, a, b, c, 0x80deb1fe, w13 = BE32(chunk[13]));
- Round(c, d, e, f, g, h, a, b, 0x9bdc06a7, w14 = BE32(chunk[14]));
- Round(b, c, d, e, f, g, h, a, 0xc19bf174, w15 = BE32(chunk[15]));
-
- Round(a, b, c, d, e, f, g, h, 0xe49b69c1, w0 += sigma1(w14) + w9 + sigma0(w1));
- Round(h, a, b, c, d, e, f, g, 0xefbe4786, w1 += sigma1(w15) + w10 + sigma0(w2));
- Round(g, h, a, b, c, d, e, f, 0x0fc19dc6, w2 += sigma1(w0) + w11 + sigma0(w3));
- Round(f, g, h, a, b, c, d, e, 0x240ca1cc, w3 += sigma1(w1) + w12 + sigma0(w4));
- Round(e, f, g, h, a, b, c, d, 0x2de92c6f, w4 += sigma1(w2) + w13 + sigma0(w5));
- Round(d, e, f, g, h, a, b, c, 0x4a7484aa, w5 += sigma1(w3) + w14 + sigma0(w6));
- Round(c, d, e, f, g, h, a, b, 0x5cb0a9dc, w6 += sigma1(w4) + w15 + sigma0(w7));
- Round(b, c, d, e, f, g, h, a, 0x76f988da, w7 += sigma1(w5) + w0 + sigma0(w8));
- Round(a, b, c, d, e, f, g, h, 0x983e5152, w8 += sigma1(w6) + w1 + sigma0(w9));
- Round(h, a, b, c, d, e, f, g, 0xa831c66d, w9 += sigma1(w7) + w2 + sigma0(w10));
- Round(g, h, a, b, c, d, e, f, 0xb00327c8, w10 += sigma1(w8) + w3 + sigma0(w11));
- Round(f, g, h, a, b, c, d, e, 0xbf597fc7, w11 += sigma1(w9) + w4 + sigma0(w12));
- Round(e, f, g, h, a, b, c, d, 0xc6e00bf3, w12 += sigma1(w10) + w5 + sigma0(w13));
- Round(d, e, f, g, h, a, b, c, 0xd5a79147, w13 += sigma1(w11) + w6 + sigma0(w14));
- Round(c, d, e, f, g, h, a, b, 0x06ca6351, w14 += sigma1(w12) + w7 + sigma0(w15));
- Round(b, c, d, e, f, g, h, a, 0x14292967, w15 += sigma1(w13) + w8 + sigma0(w0));
-
- Round(a, b, c, d, e, f, g, h, 0x27b70a85, w0 += sigma1(w14) + w9 + sigma0(w1));
- Round(h, a, b, c, d, e, f, g, 0x2e1b2138, w1 += sigma1(w15) + w10 + sigma0(w2));
- Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc, w2 += sigma1(w0) + w11 + sigma0(w3));
- Round(f, g, h, a, b, c, d, e, 0x53380d13, w3 += sigma1(w1) + w12 + sigma0(w4));
- Round(e, f, g, h, a, b, c, d, 0x650a7354, w4 += sigma1(w2) + w13 + sigma0(w5));
- Round(d, e, f, g, h, a, b, c, 0x766a0abb, w5 += sigma1(w3) + w14 + sigma0(w6));
- Round(c, d, e, f, g, h, a, b, 0x81c2c92e, w6 += sigma1(w4) + w15 + sigma0(w7));
- Round(b, c, d, e, f, g, h, a, 0x92722c85, w7 += sigma1(w5) + w0 + sigma0(w8));
- Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1, w8 += sigma1(w6) + w1 + sigma0(w9));
- Round(h, a, b, c, d, e, f, g, 0xa81a664b, w9 += sigma1(w7) + w2 + sigma0(w10));
- Round(g, h, a, b, c, d, e, f, 0xc24b8b70, w10 += sigma1(w8) + w3 + sigma0(w11));
- Round(f, g, h, a, b, c, d, e, 0xc76c51a3, w11 += sigma1(w9) + w4 + sigma0(w12));
- Round(e, f, g, h, a, b, c, d, 0xd192e819, w12 += sigma1(w10) + w5 + sigma0(w13));
- Round(d, e, f, g, h, a, b, c, 0xd6990624, w13 += sigma1(w11) + w6 + sigma0(w14));
- Round(c, d, e, f, g, h, a, b, 0xf40e3585, w14 += sigma1(w12) + w7 + sigma0(w15));
- Round(b, c, d, e, f, g, h, a, 0x106aa070, w15 += sigma1(w13) + w8 + sigma0(w0));
-
- Round(a, b, c, d, e, f, g, h, 0x19a4c116, w0 += sigma1(w14) + w9 + sigma0(w1));
- Round(h, a, b, c, d, e, f, g, 0x1e376c08, w1 += sigma1(w15) + w10 + sigma0(w2));
- Round(g, h, a, b, c, d, e, f, 0x2748774c, w2 += sigma1(w0) + w11 + sigma0(w3));
- Round(f, g, h, a, b, c, d, e, 0x34b0bcb5, w3 += sigma1(w1) + w12 + sigma0(w4));
- Round(e, f, g, h, a, b, c, d, 0x391c0cb3, w4 += sigma1(w2) + w13 + sigma0(w5));
- Round(d, e, f, g, h, a, b, c, 0x4ed8aa4a, w5 += sigma1(w3) + w14 + sigma0(w6));
- Round(c, d, e, f, g, h, a, b, 0x5b9cca4f, w6 += sigma1(w4) + w15 + sigma0(w7));
- Round(b, c, d, e, f, g, h, a, 0x682e6ff3, w7 += sigma1(w5) + w0 + sigma0(w8));
- Round(a, b, c, d, e, f, g, h, 0x748f82ee, w8 += sigma1(w6) + w1 + sigma0(w9));
- Round(h, a, b, c, d, e, f, g, 0x78a5636f, w9 += sigma1(w7) + w2 + sigma0(w10));
- Round(g, h, a, b, c, d, e, f, 0x84c87814, w10 += sigma1(w8) + w3 + sigma0(w11));
- Round(f, g, h, a, b, c, d, e, 0x8cc70208, w11 += sigma1(w9) + w4 + sigma0(w12));
- Round(e, f, g, h, a, b, c, d, 0x90befffa, w12 += sigma1(w10) + w5 + sigma0(w13));
- Round(d, e, f, g, h, a, b, c, 0xa4506ceb, w13 += sigma1(w11) + w6 + sigma0(w14));
- Round(c, d, e, f, g, h, a, b, 0xbef9a3f7, w14 + sigma1(w12) + w7 + sigma0(w15));
- Round(b, c, d, e, f, g, h, a, 0xc67178f2, w15 + sigma1(w13) + w8 + sigma0(w0));
-
- s[0] += a;
- s[1] += b;
- s[2] += c;
- s[3] += d;
- s[4] += e;
- s[5] += f;
- s[6] += g;
- s[7] += h;
-}
-
-static void secp256k1_sha256_write(secp256k1_sha256_t *hash, const unsigned char *data, size_t len) {
- size_t bufsize = hash->bytes & 0x3F;
- hash->bytes += len;
- while (bufsize + len >= 64) {
- /* Fill the buffer, and process it. */
- memcpy(((unsigned char*)hash->buf) + bufsize, data, 64 - bufsize);
- data += 64 - bufsize;
- len -= 64 - bufsize;
- secp256k1_sha256_transform(hash->s, hash->buf);
- bufsize = 0;
- }
- if (len) {
- /* Fill the buffer with what remains. */
- memcpy(((unsigned char*)hash->buf) + bufsize, data, len);
- }
-}
-
-static void secp256k1_sha256_finalize(secp256k1_sha256_t *hash, unsigned char *out32) {
- static const unsigned char pad[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- uint32_t sizedesc[2];
- uint32_t out[8];
- int i = 0;
- sizedesc[0] = BE32(hash->bytes >> 29);
- sizedesc[1] = BE32(hash->bytes << 3);
- secp256k1_sha256_write(hash, pad, 1 + ((119 - (hash->bytes % 64)) % 64));
- secp256k1_sha256_write(hash, (const unsigned char*)sizedesc, 8);
- for (i = 0; i < 8; i++) {
- out[i] = BE32(hash->s[i]);
- hash->s[i] = 0;
- }
- memcpy(out32, (const unsigned char*)out, 32);
-}
-
-static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256_t *hash, const unsigned char *key, size_t keylen) {
- int n;
- unsigned char rkey[64];
- if (keylen <= 64) {
- memcpy(rkey, key, keylen);
- memset(rkey + keylen, 0, 64 - keylen);
- } else {
- secp256k1_sha256_t sha256;
- secp256k1_sha256_initialize(&sha256);
- secp256k1_sha256_write(&sha256, key, keylen);
- secp256k1_sha256_finalize(&sha256, rkey);
- memset(rkey + 32, 0, 32);
- }
-
- secp256k1_sha256_initialize(&hash->outer);
- for (n = 0; n < 64; n++) {
- rkey[n] ^= 0x5c;
- }
- secp256k1_sha256_write(&hash->outer, rkey, 64);
-
- secp256k1_sha256_initialize(&hash->inner);
- for (n = 0; n < 64; n++) {
- rkey[n] ^= 0x5c ^ 0x36;
- }
- secp256k1_sha256_write(&hash->inner, rkey, 64);
- memset(rkey, 0, 64);
-}
-
-static void secp256k1_hmac_sha256_write(secp256k1_hmac_sha256_t *hash, const unsigned char *data, size_t size) {
- secp256k1_sha256_write(&hash->inner, data, size);
-}
-
-static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256_t *hash, unsigned char *out32) {
- unsigned char temp[32];
- secp256k1_sha256_finalize(&hash->inner, temp);
- secp256k1_sha256_write(&hash->outer, temp, 32);
- memset(temp, 0, 32);
- secp256k1_sha256_finalize(&hash->outer, out32);
-}
-
-
-static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen) {
- secp256k1_hmac_sha256_t hmac;
- static const unsigned char zero[1] = {0x00};
- static const unsigned char one[1] = {0x01};
-
- memset(rng->v, 0x01, 32); /* RFC6979 3.2.b. */
- memset(rng->k, 0x00, 32); /* RFC6979 3.2.c. */
-
- /* RFC6979 3.2.d. */
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_write(&hmac, zero, 1);
- secp256k1_hmac_sha256_write(&hmac, key, keylen);
- secp256k1_hmac_sha256_finalize(&hmac, rng->k);
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_finalize(&hmac, rng->v);
-
- /* RFC6979 3.2.f. */
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_write(&hmac, one, 1);
- secp256k1_hmac_sha256_write(&hmac, key, keylen);
- secp256k1_hmac_sha256_finalize(&hmac, rng->k);
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_finalize(&hmac, rng->v);
- rng->retry = 0;
-}
-
-static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256_t *rng, unsigned char *out, size_t outlen) {
- /* RFC6979 3.2.h. */
- static const unsigned char zero[1] = {0x00};
- if (rng->retry) {
- secp256k1_hmac_sha256_t hmac;
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_write(&hmac, zero, 1);
- secp256k1_hmac_sha256_finalize(&hmac, rng->k);
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_finalize(&hmac, rng->v);
- }
-
- while (outlen > 0) {
- secp256k1_hmac_sha256_t hmac;
- int now = outlen;
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_finalize(&hmac, rng->v);
- if (now > 32) {
- now = 32;
- }
- memcpy(out, rng->v, now);
- out += now;
- outlen -= now;
- }
-
- rng->retry = 1;
-}
-
-static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256_t *rng) {
- memset(rng->k, 0, 32);
- memset(rng->v, 0, 32);
- rng->retry = 0;
-}
-
-#undef BE32
-#undef Round
-#undef sigma1
-#undef sigma0
-#undef Sigma1
-#undef Sigma0
-#undef Maj
-#undef Ch
-
-#endif
(deleted)
+0
-446
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1.java op-geth/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1.java
deleted file mode 100644
index 1c67802fba82e60498c560473e9966c161939ffb..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1.java
+++ /dev/null
@@ -1,446 +0,0 @@
-/*
- * Copyright 2013 Google Inc.
- * Copyright 2014-2016 the libsecp256k1 contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.bitcoin;
-
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-
-import java.math.BigInteger;
-import com.google.common.base.Preconditions;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-import static org.bitcoin.NativeSecp256k1Util.*;
-
-/**
- * <p>This class holds native methods to handle ECDSA verification.</p>
- *
- * <p>You can find an example library that can be used for this at https://github.com/bitcoin/secp256k1</p>
- *
- * <p>To build secp256k1 for use with bitcoinj, run
- * `./configure --enable-jni --enable-experimental --enable-module-ecdh`
- * and `make` then copy `.libs/libsecp256k1.so` to your system library path
- * or point the JVM to the folder containing it with -Djava.library.path
- * </p>
- */
-public class NativeSecp256k1 {
-
- private static final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
- private static final Lock r = rwl.readLock();
- private static final Lock w = rwl.writeLock();
- private static ThreadLocal<ByteBuffer> nativeECDSABuffer = new ThreadLocal<ByteBuffer>();
- /**
- * Verifies the given secp256k1 signature in native code.
- * Calling when enabled == false is undefined (probably library not loaded)
- *
- * @param data The data which was signed, must be exactly 32 bytes
- * @param signature The signature
- * @param pub The public key which did the signing
- */
- public static boolean verify(byte[] data, byte[] signature, byte[] pub) throws AssertFailException{
- Preconditions.checkArgument(data.length == 32 && signature.length <= 520 && pub.length <= 520);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < 520) {
- byteBuff = ByteBuffer.allocateDirect(520);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(data);
- byteBuff.put(signature);
- byteBuff.put(pub);
-
- byte[][] retByteArray;
-
- r.lock();
- try {
- return secp256k1_ecdsa_verify(byteBuff, Secp256k1Context.getContext(), signature.length, pub.length) == 1;
- } finally {
- r.unlock();
- }
- }
-
- /**
- * libsecp256k1 Create an ECDSA signature.
- *
- * @param data Message hash, 32 bytes
- * @param key Secret key, 32 bytes
- *
- * Return values
- * @param sig byte array of signature
- */
- public static byte[] sign(byte[] data, byte[] sec) throws AssertFailException{
- Preconditions.checkArgument(data.length == 32 && sec.length <= 32);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < 32 + 32) {
- byteBuff = ByteBuffer.allocateDirect(32 + 32);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(data);
- byteBuff.put(sec);
-
- byte[][] retByteArray;
-
- r.lock();
- try {
- retByteArray = secp256k1_ecdsa_sign(byteBuff, Secp256k1Context.getContext());
- } finally {
- r.unlock();
- }
-
- byte[] sigArr = retByteArray[0];
- int sigLen = new BigInteger(new byte[] { retByteArray[1][0] }).intValue();
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(sigArr.length, sigLen, "Got bad signature length.");
-
- return retVal == 0 ? new byte[0] : sigArr;
- }
-
- /**
- * libsecp256k1 Seckey Verify - returns 1 if valid, 0 if invalid
- *
- * @param seckey ECDSA Secret key, 32 bytes
- */
- public static boolean secKeyVerify(byte[] seckey) {
- Preconditions.checkArgument(seckey.length == 32);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < seckey.length) {
- byteBuff = ByteBuffer.allocateDirect(seckey.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(seckey);
-
- r.lock();
- try {
- return secp256k1_ec_seckey_verify(byteBuff,Secp256k1Context.getContext()) == 1;
- } finally {
- r.unlock();
- }
- }
-
-
- /**
- * libsecp256k1 Compute Pubkey - computes public key from secret key
- *
- * @param seckey ECDSA Secret key, 32 bytes
- *
- * Return values
- * @param pubkey ECDSA Public key, 33 or 65 bytes
- */
- //TODO add a 'compressed' arg
- public static byte[] computePubkey(byte[] seckey) throws AssertFailException{
- Preconditions.checkArgument(seckey.length == 32);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < seckey.length) {
- byteBuff = ByteBuffer.allocateDirect(seckey.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(seckey);
-
- byte[][] retByteArray;
-
- r.lock();
- try {
- retByteArray = secp256k1_ec_pubkey_create(byteBuff, Secp256k1Context.getContext());
- } finally {
- r.unlock();
- }
-
- byte[] pubArr = retByteArray[0];
- int pubLen = new BigInteger(new byte[] { retByteArray[1][0] }).intValue();
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(pubArr.length, pubLen, "Got bad pubkey length.");
-
- return retVal == 0 ? new byte[0]: pubArr;
- }
-
- /**
- * libsecp256k1 Cleanup - This destroys the secp256k1 context object
- * This should be called at the end of the program for proper cleanup of the context.
- */
- public static synchronized void cleanup() {
- w.lock();
- try {
- secp256k1_destroy_context(Secp256k1Context.getContext());
- } finally {
- w.unlock();
- }
- }
-
- public static long cloneContext() {
- r.lock();
- try {
- return secp256k1_ctx_clone(Secp256k1Context.getContext());
- } finally { r.unlock(); }
- }
-
- /**
- * libsecp256k1 PrivKey Tweak-Mul - Tweak privkey by multiplying to it
- *
- * @param tweak some bytes to tweak with
- * @param seckey 32-byte seckey
- */
- public static byte[] privKeyTweakMul(byte[] privkey, byte[] tweak) throws AssertFailException{
- Preconditions.checkArgument(privkey.length == 32);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < privkey.length + tweak.length) {
- byteBuff = ByteBuffer.allocateDirect(privkey.length + tweak.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(privkey);
- byteBuff.put(tweak);
-
- byte[][] retByteArray;
- r.lock();
- try {
- retByteArray = secp256k1_privkey_tweak_mul(byteBuff,Secp256k1Context.getContext());
- } finally {
- r.unlock();
- }
-
- byte[] privArr = retByteArray[0];
-
- int privLen = (byte) new BigInteger(new byte[] { retByteArray[1][0] }).intValue() & 0xFF;
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(privArr.length, privLen, "Got bad pubkey length.");
-
- assertEquals(retVal, 1, "Failed return value check.");
-
- return privArr;
- }
-
- /**
- * libsecp256k1 PrivKey Tweak-Add - Tweak privkey by adding to it
- *
- * @param tweak some bytes to tweak with
- * @param seckey 32-byte seckey
- */
- public static byte[] privKeyTweakAdd(byte[] privkey, byte[] tweak) throws AssertFailException{
- Preconditions.checkArgument(privkey.length == 32);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < privkey.length + tweak.length) {
- byteBuff = ByteBuffer.allocateDirect(privkey.length + tweak.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(privkey);
- byteBuff.put(tweak);
-
- byte[][] retByteArray;
- r.lock();
- try {
- retByteArray = secp256k1_privkey_tweak_add(byteBuff,Secp256k1Context.getContext());
- } finally {
- r.unlock();
- }
-
- byte[] privArr = retByteArray[0];
-
- int privLen = (byte) new BigInteger(new byte[] { retByteArray[1][0] }).intValue() & 0xFF;
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(privArr.length, privLen, "Got bad pubkey length.");
-
- assertEquals(retVal, 1, "Failed return value check.");
-
- return privArr;
- }
-
- /**
- * libsecp256k1 PubKey Tweak-Add - Tweak pubkey by adding to it
- *
- * @param tweak some bytes to tweak with
- * @param pubkey 32-byte seckey
- */
- public static byte[] pubKeyTweakAdd(byte[] pubkey, byte[] tweak) throws AssertFailException{
- Preconditions.checkArgument(pubkey.length == 33 || pubkey.length == 65);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < pubkey.length + tweak.length) {
- byteBuff = ByteBuffer.allocateDirect(pubkey.length + tweak.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(pubkey);
- byteBuff.put(tweak);
-
- byte[][] retByteArray;
- r.lock();
- try {
- retByteArray = secp256k1_pubkey_tweak_add(byteBuff,Secp256k1Context.getContext(), pubkey.length);
- } finally {
- r.unlock();
- }
-
- byte[] pubArr = retByteArray[0];
-
- int pubLen = (byte) new BigInteger(new byte[] { retByteArray[1][0] }).intValue() & 0xFF;
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(pubArr.length, pubLen, "Got bad pubkey length.");
-
- assertEquals(retVal, 1, "Failed return value check.");
-
- return pubArr;
- }
-
- /**
- * libsecp256k1 PubKey Tweak-Mul - Tweak pubkey by multiplying to it
- *
- * @param tweak some bytes to tweak with
- * @param pubkey 32-byte seckey
- */
- public static byte[] pubKeyTweakMul(byte[] pubkey, byte[] tweak) throws AssertFailException{
- Preconditions.checkArgument(pubkey.length == 33 || pubkey.length == 65);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < pubkey.length + tweak.length) {
- byteBuff = ByteBuffer.allocateDirect(pubkey.length + tweak.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(pubkey);
- byteBuff.put(tweak);
-
- byte[][] retByteArray;
- r.lock();
- try {
- retByteArray = secp256k1_pubkey_tweak_mul(byteBuff,Secp256k1Context.getContext(), pubkey.length);
- } finally {
- r.unlock();
- }
-
- byte[] pubArr = retByteArray[0];
-
- int pubLen = (byte) new BigInteger(new byte[] { retByteArray[1][0] }).intValue() & 0xFF;
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(pubArr.length, pubLen, "Got bad pubkey length.");
-
- assertEquals(retVal, 1, "Failed return value check.");
-
- return pubArr;
- }
-
- /**
- * libsecp256k1 create ECDH secret - constant time ECDH calculation
- *
- * @param seckey byte array of secret key used in exponentiaion
- * @param pubkey byte array of public key used in exponentiaion
- */
- public static byte[] createECDHSecret(byte[] seckey, byte[] pubkey) throws AssertFailException{
- Preconditions.checkArgument(seckey.length <= 32 && pubkey.length <= 65);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < 32 + pubkey.length) {
- byteBuff = ByteBuffer.allocateDirect(32 + pubkey.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(seckey);
- byteBuff.put(pubkey);
-
- byte[][] retByteArray;
- r.lock();
- try {
- retByteArray = secp256k1_ecdh(byteBuff, Secp256k1Context.getContext(), pubkey.length);
- } finally {
- r.unlock();
- }
-
- byte[] resArr = retByteArray[0];
- int retVal = new BigInteger(new byte[] { retByteArray[1][0] }).intValue();
-
- assertEquals(resArr.length, 32, "Got bad result length.");
- assertEquals(retVal, 1, "Failed return value check.");
-
- return resArr;
- }
-
- /**
- * libsecp256k1 randomize - updates the context randomization
- *
- * @param seed 32-byte random seed
- */
- public static synchronized boolean randomize(byte[] seed) throws AssertFailException{
- Preconditions.checkArgument(seed.length == 32 || seed == null);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < seed.length) {
- byteBuff = ByteBuffer.allocateDirect(seed.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(seed);
-
- w.lock();
- try {
- return secp256k1_context_randomize(byteBuff, Secp256k1Context.getContext()) == 1;
- } finally {
- w.unlock();
- }
- }
-
- private static native long secp256k1_ctx_clone(long context);
-
- private static native int secp256k1_context_randomize(ByteBuffer byteBuff, long context);
-
- private static native byte[][] secp256k1_privkey_tweak_add(ByteBuffer byteBuff, long context);
-
- private static native byte[][] secp256k1_privkey_tweak_mul(ByteBuffer byteBuff, long context);
-
- private static native byte[][] secp256k1_pubkey_tweak_add(ByteBuffer byteBuff, long context, int pubLen);
-
- private static native byte[][] secp256k1_pubkey_tweak_mul(ByteBuffer byteBuff, long context, int pubLen);
-
- private static native void secp256k1_destroy_context(long context);
-
- private static native int secp256k1_ecdsa_verify(ByteBuffer byteBuff, long context, int sigLen, int pubLen);
-
- private static native byte[][] secp256k1_ecdsa_sign(ByteBuffer byteBuff, long context);
-
- private static native int secp256k1_ec_seckey_verify(ByteBuffer byteBuff, long context);
-
- private static native byte[][] secp256k1_ec_pubkey_create(ByteBuffer byteBuff, long context);
-
- private static native byte[][] secp256k1_ec_pubkey_parse(ByteBuffer byteBuff, long context, int inputLen);
-
- private static native byte[][] secp256k1_ecdh(ByteBuffer byteBuff, long context, int inputLen);
-
-}
(deleted)
+0
-226
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Test.java op-geth/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Test.java
deleted file mode 100644
index c00d08899b9b004af75a4e98569c460ad83395a1..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Test.java
+++ /dev/null
@@ -1,226 +0,0 @@
-package org.bitcoin;
-
-import com.google.common.io.BaseEncoding;
-import java.util.Arrays;
-import java.math.BigInteger;
-import javax.xml.bind.DatatypeConverter;
-import static org.bitcoin.NativeSecp256k1Util.*;
-
-/**
- * This class holds test cases defined for testing this library.
- */
-public class NativeSecp256k1Test {
-
- //TODO improve comments/add more tests
- /**
- * This tests verify() for a valid signature
- */
- public static void testVerifyPos() throws AssertFailException{
- boolean result = false;
- byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()); //sha256hash of "testing"
- byte[] sig = BaseEncoding.base16().lowerCase().decode("3044022079BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F817980220294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".toLowerCase());
- byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
-
- result = NativeSecp256k1.verify( data, sig, pub);
- assertEquals( result, true , "testVerifyPos");
- }
-
- /**
- * This tests verify() for a non-valid signature
- */
- public static void testVerifyNeg() throws AssertFailException{
- boolean result = false;
- byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A91".toLowerCase()); //sha256hash of "testing"
- byte[] sig = BaseEncoding.base16().lowerCase().decode("3044022079BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F817980220294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".toLowerCase());
- byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
-
- result = NativeSecp256k1.verify( data, sig, pub);
- //System.out.println(" TEST " + new BigInteger(1, resultbytes).toString(16));
- assertEquals( result, false , "testVerifyNeg");
- }
-
- /**
- * This tests secret key verify() for a valid secretkey
- */
- public static void testSecKeyVerifyPos() throws AssertFailException{
- boolean result = false;
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
-
- result = NativeSecp256k1.secKeyVerify( sec );
- //System.out.println(" TEST " + new BigInteger(1, resultbytes).toString(16));
- assertEquals( result, true , "testSecKeyVerifyPos");
- }
-
- /**
- * This tests secret key verify() for a invalid secretkey
- */
- public static void testSecKeyVerifyNeg() throws AssertFailException{
- boolean result = false;
- byte[] sec = BaseEncoding.base16().lowerCase().decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase());
-
- result = NativeSecp256k1.secKeyVerify( sec );
- //System.out.println(" TEST " + new BigInteger(1, resultbytes).toString(16));
- assertEquals( result, false , "testSecKeyVerifyNeg");
- }
-
- /**
- * This tests public key create() for a valid secretkey
- */
- public static void testPubKeyCreatePos() throws AssertFailException{
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
-
- byte[] resultArr = NativeSecp256k1.computePubkey( sec);
- String pubkeyString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( pubkeyString , "04C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D2103ED494718C697AC9AEBCFD19612E224DB46661011863ED2FC54E71861E2A6" , "testPubKeyCreatePos");
- }
-
- /**
- * This tests public key create() for a invalid secretkey
- */
- public static void testPubKeyCreateNeg() throws AssertFailException{
- byte[] sec = BaseEncoding.base16().lowerCase().decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase());
-
- byte[] resultArr = NativeSecp256k1.computePubkey( sec);
- String pubkeyString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( pubkeyString, "" , "testPubKeyCreateNeg");
- }
-
- /**
- * This tests sign() for a valid secretkey
- */
- public static void testSignPos() throws AssertFailException{
-
- byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()); //sha256hash of "testing"
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
-
- byte[] resultArr = NativeSecp256k1.sign(data, sec);
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString, "30440220182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A202201C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9" , "testSignPos");
- }
-
- /**
- * This tests sign() for a invalid secretkey
- */
- public static void testSignNeg() throws AssertFailException{
- byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()); //sha256hash of "testing"
- byte[] sec = BaseEncoding.base16().lowerCase().decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase());
-
- byte[] resultArr = NativeSecp256k1.sign(data, sec);
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString, "" , "testSignNeg");
- }
-
- /**
- * This tests private key tweak-add
- */
- public static void testPrivKeyTweakAdd_1() throws AssertFailException {
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
- byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
-
- byte[] resultArr = NativeSecp256k1.privKeyTweakAdd( sec , data );
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString , "A168571E189E6F9A7E2D657A4B53AE99B909F7E712D1C23CED28093CD57C88F3" , "testPrivKeyAdd_1");
- }
-
- /**
- * This tests private key tweak-mul
- */
- public static void testPrivKeyTweakMul_1() throws AssertFailException {
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
- byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
-
- byte[] resultArr = NativeSecp256k1.privKeyTweakMul( sec , data );
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString , "97F8184235F101550F3C71C927507651BD3F1CDB4A5A33B8986ACF0DEE20FFFC" , "testPrivKeyMul_1");
- }
-
- /**
- * This tests private key tweak-add uncompressed
- */
- public static void testPrivKeyTweakAdd_2() throws AssertFailException {
- byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
- byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
-
- byte[] resultArr = NativeSecp256k1.pubKeyTweakAdd( pub , data );
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString , "0411C6790F4B663CCE607BAAE08C43557EDC1A4D11D88DFCB3D841D0C6A941AF525A268E2A863C148555C48FB5FBA368E88718A46E205FABC3DBA2CCFFAB0796EF" , "testPrivKeyAdd_2");
- }
-
- /**
- * This tests private key tweak-mul uncompressed
- */
- public static void testPrivKeyTweakMul_2() throws AssertFailException {
- byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
- byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
-
- byte[] resultArr = NativeSecp256k1.pubKeyTweakMul( pub , data );
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString , "04E0FE6FE55EBCA626B98A807F6CAF654139E14E5E3698F01A9A658E21DC1D2791EC060D4F412A794D5370F672BC94B722640B5F76914151CFCA6E712CA48CC589" , "testPrivKeyMul_2");
- }
-
- /**
- * This tests seed randomization
- */
- public static void testRandomize() throws AssertFailException {
- byte[] seed = BaseEncoding.base16().lowerCase().decode("A441B15FE9A3CF56661190A0B93B9DEC7D04127288CC87250967CF3B52894D11".toLowerCase()); //sha256hash of "random"
- boolean result = NativeSecp256k1.randomize(seed);
- assertEquals( result, true, "testRandomize");
- }
-
- public static void testCreateECDHSecret() throws AssertFailException{
-
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
- byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
-
- byte[] resultArr = NativeSecp256k1.createECDHSecret(sec, pub);
- String ecdhString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( ecdhString, "2A2A67007A926E6594AF3EB564FC74005B37A9C8AEF2033C4552051B5C87F043" , "testCreateECDHSecret");
- }
-
- public static void main(String[] args) throws AssertFailException{
-
-
- System.out.println("\n libsecp256k1 enabled: " + Secp256k1Context.isEnabled() + "\n");
-
- assertEquals( Secp256k1Context.isEnabled(), true, "isEnabled" );
-
- //Test verify() success/fail
- testVerifyPos();
- testVerifyNeg();
-
- //Test secKeyVerify() success/fail
- testSecKeyVerifyPos();
- testSecKeyVerifyNeg();
-
- //Test computePubkey() success/fail
- testPubKeyCreatePos();
- testPubKeyCreateNeg();
-
- //Test sign() success/fail
- testSignPos();
- testSignNeg();
-
- //Test privKeyTweakAdd() 1
- testPrivKeyTweakAdd_1();
-
- //Test privKeyTweakMul() 2
- testPrivKeyTweakMul_1();
-
- //Test privKeyTweakAdd() 3
- testPrivKeyTweakAdd_2();
-
- //Test privKeyTweakMul() 4
- testPrivKeyTweakMul_2();
-
- //Test randomize()
- testRandomize();
-
- //Test ECDH
- testCreateECDHSecret();
-
- NativeSecp256k1.cleanup();
-
- System.out.println(" All tests passed." );
-
- }
-}
(deleted)
+0
-45
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Util.java op-geth/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Util.java
deleted file mode 100644
index 04732ba044363a5dc5c525661a090c1bdf1d077f..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Util.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright 2014-2016 the libsecp256k1 contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.bitcoin;
-
-public class NativeSecp256k1Util{
-
- public static void assertEquals( int val, int val2, String message ) throws AssertFailException{
- if( val != val2 )
- throw new AssertFailException("FAIL: " + message);
- }
-
- public static void assertEquals( boolean val, boolean val2, String message ) throws AssertFailException{
- if( val != val2 )
- throw new AssertFailException("FAIL: " + message);
- else
- System.out.println("PASS: " + message);
- }
-
- public static void assertEquals( String val, String val2, String message ) throws AssertFailException{
- if( !val.equals(val2) )
- throw new AssertFailException("FAIL: " + message);
- else
- System.out.println("PASS: " + message);
- }
-
- public static class AssertFailException extends Exception {
- public AssertFailException(String message) {
- super( message );
- }
- }
-}
(deleted)
+0
-51
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/Secp256k1Context.java op-geth/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/Secp256k1Context.java
deleted file mode 100644
index 216c986a8b564d49b01243d513bdd182339e51b6..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/Secp256k1Context.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright 2014-2016 the libsecp256k1 contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.bitcoin;
-
-/**
- * This class holds the context reference used in native methods
- * to handle ECDSA operations.
- */
-public class Secp256k1Context {
- private static final boolean enabled; //true if the library is loaded
- private static final long context; //ref to pointer to context obj
-
- static { //static initializer
- boolean isEnabled = true;
- long contextRef = -1;
- try {
- System.loadLibrary("secp256k1");
- contextRef = secp256k1_init_context();
- } catch (UnsatisfiedLinkError e) {
- System.out.println("UnsatisfiedLinkError: " + e.toString());
- isEnabled = false;
- }
- enabled = isEnabled;
- context = contextRef;
- }
-
- public static boolean isEnabled() {
- return enabled;
- }
-
- public static long getContext() {
- if(!enabled) return -1; //sanity check
- return context;
- }
-
- private static native long secp256k1_init_context();
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.c op-geth/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.c
deleted file mode 100644
index bcef7b32ce3e7fe1587f15dac2e7c56fef998a8a..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.c
+++ /dev/null
@@ -1,377 +0,0 @@
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include "org_bitcoin_NativeSecp256k1.h"
-#include "include/secp256k1.h"
-#include "include/secp256k1_ecdh.h"
-#include "include/secp256k1_recovery.h"
-
-
-SECP256K1_API jlong JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ctx_1clone
- (JNIEnv* env, jclass classObject, jlong ctx_l)
-{
- const secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
-
- jlong ctx_clone_l = (uintptr_t) secp256k1_context_clone(ctx);
-
- (void)classObject;(void)env;
-
- return ctx_clone_l;
-
-}
-
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1context_1randomize
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
-
- const unsigned char* seed = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
-
- (void)classObject;
-
- return secp256k1_context_randomize(ctx, seed);
-
-}
-
-SECP256K1_API void JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1destroy_1context
- (JNIEnv* env, jclass classObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
-
- secp256k1_context_destroy(ctx);
-
- (void)classObject;(void)env;
-}
-
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1verify
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint siglen, jint publen)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
-
- unsigned char* data = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* sigdata = { (unsigned char*) (data + 32) };
- const unsigned char* pubdata = { (unsigned char*) (data + siglen + 32) };
-
- secp256k1_ecdsa_signature sig;
- secp256k1_pubkey pubkey;
-
- int ret = secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigdata, siglen);
-
- if( ret ) {
- ret = secp256k1_ec_pubkey_parse(ctx, &pubkey, pubdata, publen);
-
- if( ret ) {
- ret = secp256k1_ecdsa_verify(ctx, &sig, data, &pubkey);
- }
- }
-
- (void)classObject;
-
- return ret;
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1sign
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- unsigned char* data = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
- unsigned char* secKey = (unsigned char*) (data + 32);
-
- jobjectArray retArray;
- jbyteArray sigArray, intsByteArray;
- unsigned char intsarray[2];
-
- secp256k1_ecdsa_signature sig[72];
-
- int ret = secp256k1_ecdsa_sign(ctx, sig, data, secKey, NULL, NULL );
-
- unsigned char outputSer[72];
- size_t outputLen = 72;
-
- if( ret ) {
- int ret2 = secp256k1_ecdsa_signature_serialize_der(ctx,outputSer, &outputLen, sig ); (void)ret2;
- }
-
- intsarray[0] = outputLen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- sigArray = (*env)->NewByteArray(env, outputLen);
- (*env)->SetByteArrayRegion(env, sigArray, 0, outputLen, (jbyte*)outputSer);
- (*env)->SetObjectArrayElement(env, retArray, 0, sigArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
-
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1seckey_1verify
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- unsigned char* secKey = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
-
- (void)classObject;
-
- return secp256k1_ec_seckey_verify(ctx, secKey);
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1pubkey_1create
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- const unsigned char* secKey = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
-
- secp256k1_pubkey pubkey;
-
- jobjectArray retArray;
- jbyteArray pubkeyArray, intsByteArray;
- unsigned char intsarray[2];
-
- int ret = secp256k1_ec_pubkey_create(ctx, &pubkey, secKey);
-
- unsigned char outputSer[65];
- size_t outputLen = 65;
-
- if( ret ) {
- int ret2 = secp256k1_ec_pubkey_serialize(ctx,outputSer, &outputLen, &pubkey,SECP256K1_EC_UNCOMPRESSED );(void)ret2;
- }
-
- intsarray[0] = outputLen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- pubkeyArray = (*env)->NewByteArray(env, outputLen);
- (*env)->SetByteArrayRegion(env, pubkeyArray, 0, outputLen, (jbyte*)outputSer);
- (*env)->SetObjectArrayElement(env, retArray, 0, pubkeyArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1privkey_1tweak_1add
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- unsigned char* privkey = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* tweak = (unsigned char*) (privkey + 32);
-
- jobjectArray retArray;
- jbyteArray privArray, intsByteArray;
- unsigned char intsarray[2];
-
- int privkeylen = 32;
-
- int ret = secp256k1_ec_privkey_tweak_add(ctx, privkey, tweak);
-
- intsarray[0] = privkeylen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- privArray = (*env)->NewByteArray(env, privkeylen);
- (*env)->SetByteArrayRegion(env, privArray, 0, privkeylen, (jbyte*)privkey);
- (*env)->SetObjectArrayElement(env, retArray, 0, privArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1privkey_1tweak_1mul
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- unsigned char* privkey = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* tweak = (unsigned char*) (privkey + 32);
-
- jobjectArray retArray;
- jbyteArray privArray, intsByteArray;
- unsigned char intsarray[2];
-
- int privkeylen = 32;
-
- int ret = secp256k1_ec_privkey_tweak_mul(ctx, privkey, tweak);
-
- intsarray[0] = privkeylen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- privArray = (*env)->NewByteArray(env, privkeylen);
- (*env)->SetByteArrayRegion(env, privArray, 0, privkeylen, (jbyte*)privkey);
- (*env)->SetObjectArrayElement(env, retArray, 0, privArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1pubkey_1tweak_1add
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint publen)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
-/* secp256k1_pubkey* pubkey = (secp256k1_pubkey*) (*env)->GetDirectBufferAddress(env, byteBufferObject);*/
- unsigned char* pkey = (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* tweak = (unsigned char*) (pkey + publen);
-
- jobjectArray retArray;
- jbyteArray pubArray, intsByteArray;
- unsigned char intsarray[2];
- unsigned char outputSer[65];
- size_t outputLen = 65;
-
- secp256k1_pubkey pubkey;
- int ret = secp256k1_ec_pubkey_parse(ctx, &pubkey, pkey, publen);
-
- if( ret ) {
- ret = secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, tweak);
- }
-
- if( ret ) {
- int ret2 = secp256k1_ec_pubkey_serialize(ctx,outputSer, &outputLen, &pubkey,SECP256K1_EC_UNCOMPRESSED );(void)ret2;
- }
-
- intsarray[0] = outputLen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- pubArray = (*env)->NewByteArray(env, outputLen);
- (*env)->SetByteArrayRegion(env, pubArray, 0, outputLen, (jbyte*)outputSer);
- (*env)->SetObjectArrayElement(env, retArray, 0, pubArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1pubkey_1tweak_1mul
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint publen)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- unsigned char* pkey = (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* tweak = (unsigned char*) (pkey + publen);
-
- jobjectArray retArray;
- jbyteArray pubArray, intsByteArray;
- unsigned char intsarray[2];
- unsigned char outputSer[65];
- size_t outputLen = 65;
-
- secp256k1_pubkey pubkey;
- int ret = secp256k1_ec_pubkey_parse(ctx, &pubkey, pkey, publen);
-
- if ( ret ) {
- ret = secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey, tweak);
- }
-
- if( ret ) {
- int ret2 = secp256k1_ec_pubkey_serialize(ctx,outputSer, &outputLen, &pubkey,SECP256K1_EC_UNCOMPRESSED );(void)ret2;
- }
-
- intsarray[0] = outputLen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- pubArray = (*env)->NewByteArray(env, outputLen);
- (*env)->SetByteArrayRegion(env, pubArray, 0, outputLen, (jbyte*)outputSer);
- (*env)->SetObjectArrayElement(env, retArray, 0, pubArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
-
-SECP256K1_API jlong JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1pubkey_1combine
- (JNIEnv * env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint numkeys)
-{
- (void)classObject;(void)env;(void)byteBufferObject;(void)ctx_l;(void)numkeys;
-
- return 0;
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdh
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint publen)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- const unsigned char* secdata = (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* pubdata = (const unsigned char*) (secdata + 32);
-
- jobjectArray retArray;
- jbyteArray outArray, intsByteArray;
- unsigned char intsarray[1];
- secp256k1_pubkey pubkey;
- unsigned char nonce_res[32];
- size_t outputLen = 32;
-
- int ret = secp256k1_ec_pubkey_parse(ctx, &pubkey, pubdata, publen);
-
- if (ret) {
- ret = secp256k1_ecdh(
- ctx,
- nonce_res,
- &pubkey,
- secdata
- );
- }
-
- intsarray[0] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- outArray = (*env)->NewByteArray(env, outputLen);
- (*env)->SetByteArrayRegion(env, outArray, 0, 32, (jbyte*)nonce_res);
- (*env)->SetObjectArrayElement(env, retArray, 0, outArray);
-
- intsByteArray = (*env)->NewByteArray(env, 1);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 1, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.h op-geth/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.h
deleted file mode 100644
index fe613c9e9e77eddb18e0b0d8422948678f3408a8..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/* DO NOT EDIT THIS FILE - it is machine generated */
-#include <jni.h>
-#include "include/secp256k1.h"
-/* Header for class org_bitcoin_NativeSecp256k1 */
-
-#ifndef _Included_org_bitcoin_NativeSecp256k1
-#define _Included_org_bitcoin_NativeSecp256k1
-#ifdef __cplusplus
-extern "C" {
-#endif
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ctx_clone
- * Signature: (J)J
- */
-SECP256K1_API jlong JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ctx_1clone
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_context_randomize
- * Signature: (Ljava/nio/ByteBuffer;J)I
- */
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1context_1randomize
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_privkey_tweak_add
- * Signature: (Ljava/nio/ByteBuffer;J)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1privkey_1tweak_1add
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_privkey_tweak_mul
- * Signature: (Ljava/nio/ByteBuffer;J)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1privkey_1tweak_1mul
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_pubkey_tweak_add
- * Signature: (Ljava/nio/ByteBuffer;JI)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1pubkey_1tweak_1add
- (JNIEnv *, jclass, jobject, jlong, jint);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_pubkey_tweak_mul
- * Signature: (Ljava/nio/ByteBuffer;JI)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1pubkey_1tweak_1mul
- (JNIEnv *, jclass, jobject, jlong, jint);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_destroy_context
- * Signature: (J)V
- */
-SECP256K1_API void JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1destroy_1context
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ecdsa_verify
- * Signature: (Ljava/nio/ByteBuffer;JII)I
- */
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1verify
- (JNIEnv *, jclass, jobject, jlong, jint, jint);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ecdsa_sign
- * Signature: (Ljava/nio/ByteBuffer;J)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1sign
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ec_seckey_verify
- * Signature: (Ljava/nio/ByteBuffer;J)I
- */
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1seckey_1verify
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ec_pubkey_create
- * Signature: (Ljava/nio/ByteBuffer;J)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1pubkey_1create
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ec_pubkey_parse
- * Signature: (Ljava/nio/ByteBuffer;JI)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1pubkey_1parse
- (JNIEnv *, jclass, jobject, jlong, jint);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ecdh
- * Signature: (Ljava/nio/ByteBuffer;JI)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdh
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint publen);
-
-
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.c op-geth/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.c
deleted file mode 100644
index a52939e7e7dacda374ec879d69b29ebb9add2dbc..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdlib.h>
-#include <stdint.h>
-#include "org_bitcoin_Secp256k1Context.h"
-#include "include/secp256k1.h"
-
-SECP256K1_API jlong JNICALL Java_org_bitcoin_Secp256k1Context_secp256k1_1init_1context
- (JNIEnv* env, jclass classObject)
-{
- secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
-
- (void)classObject;(void)env;
-
- return (uintptr_t)ctx;
-}
-
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.h op-geth/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.h
deleted file mode 100644
index 0d2bc84b7f3fde84f81115a037be6de105f0472b..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/* DO NOT EDIT THIS FILE - it is machine generated */
-#include <jni.h>
-#include "include/secp256k1.h"
-/* Header for class org_bitcoin_Secp256k1Context */
-
-#ifndef _Included_org_bitcoin_Secp256k1Context
-#define _Included_org_bitcoin_Secp256k1Context
-#ifdef __cplusplus
-extern "C" {
-#endif
-/*
- * Class: org_bitcoin_Secp256k1Context
- * Method: secp256k1_init_context
- * Signature: ()J
- */
-SECP256K1_API jlong JNICALL Java_org_bitcoin_Secp256k1Context_secp256k1_1init_1context
- (JNIEnv *, jclass);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/dummy.go op-geth/crypto/secp256k1/libsecp256k1/src/modules/dummy.go
deleted file mode 100644
index 99c538db51b042dcacaa0ff5396495ac52438a4b..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/dummy.go
+++ /dev/null
@@ -1,8 +0,0 @@
-//go:build dummy
-// +build dummy
-
-// Package c contains only a C file.
-//
-// This Go file is part of a workaround for `go mod vendor`.
-// Please see the file crypto/secp256k1/dummy.go for more information.
-package module
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/ecdh/Makefile.am.include op-geth/crypto/secp256k1/libsecp256k1/src/modules/ecdh/Makefile.am.include
deleted file mode 100644
index e3088b469790bdc14b8982931d5729a7eabde69b..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/ecdh/Makefile.am.include
+++ /dev/null
@@ -1,8 +0,0 @@
-include_HEADERS += include/secp256k1_ecdh.h
-noinst_HEADERS += src/modules/ecdh/main_impl.h
-noinst_HEADERS += src/modules/ecdh/tests_impl.h
-if USE_BENCHMARK
-noinst_PROGRAMS += bench_ecdh
-bench_ecdh_SOURCES = src/bench_ecdh.c
-bench_ecdh_LDADD = libsecp256k1.la $(SECP_LIBS) $(COMMON_LIB)
-endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/ecdh/dummy.go op-geth/crypto/secp256k1/libsecp256k1/src/modules/ecdh/dummy.go
deleted file mode 100644
index 48c2e0aa545363ee95a70f3e563a6630693baf46..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/ecdh/dummy.go
+++ /dev/null
@@ -1,8 +0,0 @@
-//go:build dummy
-// +build dummy
-
-// Package c contains only a C file.
-//
-// This Go file is part of a workaround for `go mod vendor`.
-// Please see the file crypto/secp256k1/dummy.go for more information.
-package ecdh
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/ecdh/main_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/modules/ecdh/main_impl.h
deleted file mode 100644
index 9e30fb73dd7fb98b6e860cfb9054f1d66fb4089a..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/ecdh/main_impl.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_MODULE_ECDH_MAIN_
-#define _SECP256K1_MODULE_ECDH_MAIN_
-
-#include "include/secp256k1_ecdh.h"
-#include "ecmult_const_impl.h"
-
-int secp256k1_ecdh(const secp256k1_context* ctx, unsigned char *result, const secp256k1_pubkey *point, const unsigned char *scalar) {
- int ret = 0;
- int overflow = 0;
- secp256k1_gej res;
- secp256k1_ge pt;
- secp256k1_scalar s;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(result != NULL);
- ARG_CHECK(point != NULL);
- ARG_CHECK(scalar != NULL);
-
- secp256k1_pubkey_load(ctx, &pt, point);
- secp256k1_scalar_set_b32(&s, scalar, &overflow);
- if (overflow || secp256k1_scalar_is_zero(&s)) {
- ret = 0;
- } else {
- unsigned char x[32];
- unsigned char y[1];
- secp256k1_sha256_t sha;
-
- secp256k1_ecmult_const(&res, &pt, &s);
- secp256k1_ge_set_gej(&pt, &res);
- /* Compute a hash of the point in compressed form
- * Note we cannot use secp256k1_eckey_pubkey_serialize here since it does not
- * expect its output to be secret and has a timing sidechannel. */
- secp256k1_fe_normalize(&pt.x);
- secp256k1_fe_normalize(&pt.y);
- secp256k1_fe_get_b32(x, &pt.x);
- y[0] = 0x02 | secp256k1_fe_is_odd(&pt.y);
-
- secp256k1_sha256_initialize(&sha);
- secp256k1_sha256_write(&sha, y, sizeof(y));
- secp256k1_sha256_write(&sha, x, sizeof(x));
- secp256k1_sha256_finalize(&sha, result);
- ret = 1;
- }
-
- secp256k1_scalar_clear(&s);
- return ret;
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/ecdh/tests_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/modules/ecdh/tests_impl.h
deleted file mode 100644
index 85a5d0a9a69e10d585c2bc2ad4df03f14cf0def6..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/ecdh/tests_impl.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_MODULE_ECDH_TESTS_
-#define _SECP256K1_MODULE_ECDH_TESTS_
-
-void test_ecdh_api(void) {
- /* Setup context that just counts errors */
- secp256k1_context *tctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
- secp256k1_pubkey point;
- unsigned char res[32];
- unsigned char s_one[32] = { 0 };
- int32_t ecount = 0;
- s_one[31] = 1;
-
- secp256k1_context_set_error_callback(tctx, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(tctx, counting_illegal_callback_fn, &ecount);
- CHECK(secp256k1_ec_pubkey_create(tctx, &point, s_one) == 1);
-
- /* Check all NULLs are detected */
- CHECK(secp256k1_ecdh(tctx, res, &point, s_one) == 1);
- CHECK(ecount == 0);
- CHECK(secp256k1_ecdh(tctx, NULL, &point, s_one) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdh(tctx, res, NULL, s_one) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdh(tctx, res, &point, NULL) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdh(tctx, res, &point, s_one) == 1);
- CHECK(ecount == 3);
-
- /* Cleanup */
- secp256k1_context_destroy(tctx);
-}
-
-void test_ecdh_generator_basepoint(void) {
- unsigned char s_one[32] = { 0 };
- secp256k1_pubkey point[2];
- int i;
-
- s_one[31] = 1;
- /* Check against pubkey creation when the basepoint is the generator */
- for (i = 0; i < 100; ++i) {
- secp256k1_sha256_t sha;
- unsigned char s_b32[32];
- unsigned char output_ecdh[32];
- unsigned char output_ser[32];
- unsigned char point_ser[33];
- size_t point_ser_len = sizeof(point_ser);
- secp256k1_scalar s;
-
- random_scalar_order(&s);
- secp256k1_scalar_get_b32(s_b32, &s);
-
- /* compute using ECDH function */
- CHECK(secp256k1_ec_pubkey_create(ctx, &point[0], s_one) == 1);
- CHECK(secp256k1_ecdh(ctx, output_ecdh, &point[0], s_b32) == 1);
- /* compute "explicitly" */
- CHECK(secp256k1_ec_pubkey_create(ctx, &point[1], s_b32) == 1);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, point_ser, &point_ser_len, &point[1], SECP256K1_EC_COMPRESSED) == 1);
- CHECK(point_ser_len == sizeof(point_ser));
- secp256k1_sha256_initialize(&sha);
- secp256k1_sha256_write(&sha, point_ser, point_ser_len);
- secp256k1_sha256_finalize(&sha, output_ser);
- /* compare */
- CHECK(memcmp(output_ecdh, output_ser, sizeof(output_ser)) == 0);
- }
-}
-
-void test_bad_scalar(void) {
- unsigned char s_zero[32] = { 0 };
- unsigned char s_overflow[32] = {
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41
- };
- unsigned char s_rand[32] = { 0 };
- unsigned char output[32];
- secp256k1_scalar rand;
- secp256k1_pubkey point;
-
- /* Create random point */
- random_scalar_order(&rand);
- secp256k1_scalar_get_b32(s_rand, &rand);
- CHECK(secp256k1_ec_pubkey_create(ctx, &point, s_rand) == 1);
-
- /* Try to multiply it by bad values */
- CHECK(secp256k1_ecdh(ctx, output, &point, s_zero) == 0);
- CHECK(secp256k1_ecdh(ctx, output, &point, s_overflow) == 0);
- /* ...and a good one */
- s_overflow[31] -= 1;
- CHECK(secp256k1_ecdh(ctx, output, &point, s_overflow) == 1);
-}
-
-void run_ecdh_tests(void) {
- test_ecdh_api();
- test_ecdh_generator_basepoint();
- test_bad_scalar();
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/recovery/Makefile.am.include op-geth/crypto/secp256k1/libsecp256k1/src/modules/recovery/Makefile.am.include
deleted file mode 100644
index bf23c26e71c5dd88df965141295bb33144007147..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/recovery/Makefile.am.include
+++ /dev/null
@@ -1,8 +0,0 @@
-include_HEADERS += include/secp256k1_recovery.h
-noinst_HEADERS += src/modules/recovery/main_impl.h
-noinst_HEADERS += src/modules/recovery/tests_impl.h
-if USE_BENCHMARK
-noinst_PROGRAMS += bench_recover
-bench_recover_SOURCES = src/bench_recover.c
-bench_recover_LDADD = libsecp256k1.la $(SECP_LIBS) $(COMMON_LIB)
-endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/recovery/dummy.go op-geth/crypto/secp256k1/libsecp256k1/src/modules/recovery/dummy.go
deleted file mode 100644
index 8efbd7abe71bdaa73fae314de40c03916edbaaa8..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/recovery/dummy.go
+++ /dev/null
@@ -1,8 +0,0 @@
-//go:build dummy
-// +build dummy
-
-// Package c contains only a C file.
-//
-// This Go file is part of a workaround for `go mod vendor`.
-// Please see the file crypto/secp256k1/dummy.go for more information.
-package recovery
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/recovery/main_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/modules/recovery/main_impl.h
deleted file mode 100755
index c6fbe239813a3e45559bd36098d3d2ca2dac145a..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/recovery/main_impl.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013-2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_MODULE_RECOVERY_MAIN_
-#define _SECP256K1_MODULE_RECOVERY_MAIN_
-
-#include "include/secp256k1_recovery.h"
-
-static void secp256k1_ecdsa_recoverable_signature_load(const secp256k1_context* ctx, secp256k1_scalar* r, secp256k1_scalar* s, int* recid, const secp256k1_ecdsa_recoverable_signature* sig) {
- (void)ctx;
- if (sizeof(secp256k1_scalar) == 32) {
- /* When the secp256k1_scalar type is exactly 32 byte, use its
- * representation inside secp256k1_ecdsa_signature, as conversion is very fast.
- * Note that secp256k1_ecdsa_signature_save must use the same representation. */
- memcpy(r, &sig->data[0], 32);
- memcpy(s, &sig->data[32], 32);
- } else {
- secp256k1_scalar_set_b32(r, &sig->data[0], NULL);
- secp256k1_scalar_set_b32(s, &sig->data[32], NULL);
- }
- *recid = sig->data[64];
-}
-
-static void secp256k1_ecdsa_recoverable_signature_save(secp256k1_ecdsa_recoverable_signature* sig, const secp256k1_scalar* r, const secp256k1_scalar* s, int recid) {
- if (sizeof(secp256k1_scalar) == 32) {
- memcpy(&sig->data[0], r, 32);
- memcpy(&sig->data[32], s, 32);
- } else {
- secp256k1_scalar_get_b32(&sig->data[0], r);
- secp256k1_scalar_get_b32(&sig->data[32], s);
- }
- sig->data[64] = recid;
-}
-
-int secp256k1_ecdsa_recoverable_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_recoverable_signature* sig, const unsigned char *input64, int recid) {
- secp256k1_scalar r, s;
- int ret = 1;
- int overflow = 0;
-
- (void)ctx;
- ARG_CHECK(sig != NULL);
- ARG_CHECK(input64 != NULL);
- ARG_CHECK(recid >= 0 && recid <= 3);
-
- secp256k1_scalar_set_b32(&r, &input64[0], &overflow);
- ret &= !overflow;
- secp256k1_scalar_set_b32(&s, &input64[32], &overflow);
- ret &= !overflow;
- if (ret) {
- secp256k1_ecdsa_recoverable_signature_save(sig, &r, &s, recid);
- } else {
- memset(sig, 0, sizeof(*sig));
- }
- return ret;
-}
-
-int secp256k1_ecdsa_recoverable_signature_serialize_compact(const secp256k1_context* ctx, unsigned char *output64, int *recid, const secp256k1_ecdsa_recoverable_signature* sig) {
- secp256k1_scalar r, s;
-
- (void)ctx;
- ARG_CHECK(output64 != NULL);
- ARG_CHECK(sig != NULL);
- ARG_CHECK(recid != NULL);
-
- secp256k1_ecdsa_recoverable_signature_load(ctx, &r, &s, recid, sig);
- secp256k1_scalar_get_b32(&output64[0], &r);
- secp256k1_scalar_get_b32(&output64[32], &s);
- return 1;
-}
-
-int secp256k1_ecdsa_recoverable_signature_convert(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const secp256k1_ecdsa_recoverable_signature* sigin) {
- secp256k1_scalar r, s;
- int recid;
-
- (void)ctx;
- ARG_CHECK(sig != NULL);
- ARG_CHECK(sigin != NULL);
-
- secp256k1_ecdsa_recoverable_signature_load(ctx, &r, &s, &recid, sigin);
- secp256k1_ecdsa_signature_save(sig, &r, &s);
- return 1;
-}
-
-static int secp256k1_ecdsa_sig_recover(const secp256k1_ecmult_context *ctx, const secp256k1_scalar *sigr, const secp256k1_scalar* sigs, secp256k1_ge *pubkey, const secp256k1_scalar *message, int recid) {
- unsigned char brx[32];
- secp256k1_fe fx;
- secp256k1_ge x;
- secp256k1_gej xj;
- secp256k1_scalar rn, u1, u2;
- secp256k1_gej qj;
- int r;
-
- if (secp256k1_scalar_is_zero(sigr) || secp256k1_scalar_is_zero(sigs)) {
- return 0;
- }
-
- secp256k1_scalar_get_b32(brx, sigr);
- r = secp256k1_fe_set_b32(&fx, brx);
- (void)r;
- VERIFY_CHECK(r); /* brx comes from a scalar, so is less than the order; certainly less than p */
- if (recid & 2) {
- if (secp256k1_fe_cmp_var(&fx, &secp256k1_ecdsa_const_p_minus_order) >= 0) {
- return 0;
- }
- secp256k1_fe_add(&fx, &secp256k1_ecdsa_const_order_as_fe);
- }
- if (!secp256k1_ge_set_xo_var(&x, &fx, recid & 1)) {
- return 0;
- }
- secp256k1_gej_set_ge(&xj, &x);
- secp256k1_scalar_inverse_var(&rn, sigr);
- secp256k1_scalar_mul(&u1, &rn, message);
- secp256k1_scalar_negate(&u1, &u1);
- secp256k1_scalar_mul(&u2, &rn, sigs);
- secp256k1_ecmult(ctx, &qj, &xj, &u2, &u1);
- secp256k1_ge_set_gej_var(pubkey, &qj);
- return !secp256k1_gej_is_infinity(&qj);
-}
-
-int secp256k1_ecdsa_sign_recoverable(const secp256k1_context* ctx, secp256k1_ecdsa_recoverable_signature *signature, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void* noncedata) {
- secp256k1_scalar r, s;
- secp256k1_scalar sec, non, msg;
- int recid;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
- ARG_CHECK(msg32 != NULL);
- ARG_CHECK(signature != NULL);
- ARG_CHECK(seckey != NULL);
- if (noncefp == NULL) {
- noncefp = secp256k1_nonce_function_default;
- }
-
- secp256k1_scalar_set_b32(&sec, seckey, &overflow);
- /* Fail if the secret key is invalid. */
- if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
- unsigned char nonce32[32];
- unsigned int count = 0;
- secp256k1_scalar_set_b32(&msg, msg32, NULL);
- while (1) {
- ret = noncefp(nonce32, msg32, seckey, NULL, (void*)noncedata, count);
- if (!ret) {
- break;
- }
- secp256k1_scalar_set_b32(&non, nonce32, &overflow);
- if (!secp256k1_scalar_is_zero(&non) && !overflow) {
- if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &r, &s, &sec, &msg, &non, &recid)) {
- break;
- }
- }
- count++;
- }
- memset(nonce32, 0, 32);
- secp256k1_scalar_clear(&msg);
- secp256k1_scalar_clear(&non);
- secp256k1_scalar_clear(&sec);
- }
- if (ret) {
- secp256k1_ecdsa_recoverable_signature_save(signature, &r, &s, recid);
- } else {
- memset(signature, 0, sizeof(*signature));
- }
- return ret;
-}
-
-int secp256k1_ecdsa_recover(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const secp256k1_ecdsa_recoverable_signature *signature, const unsigned char *msg32) {
- secp256k1_ge q;
- secp256k1_scalar r, s;
- secp256k1_scalar m;
- int recid;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
- ARG_CHECK(msg32 != NULL);
- ARG_CHECK(signature != NULL);
- ARG_CHECK(pubkey != NULL);
-
- secp256k1_ecdsa_recoverable_signature_load(ctx, &r, &s, &recid, signature);
- VERIFY_CHECK(recid >= 0 && recid < 4); /* should have been caught in parse_compact */
- secp256k1_scalar_set_b32(&m, msg32, NULL);
- if (secp256k1_ecdsa_sig_recover(&ctx->ecmult_ctx, &r, &s, &q, &m, recid)) {
- secp256k1_pubkey_save(pubkey, &q);
- return 1;
- } else {
- memset(pubkey, 0, sizeof(*pubkey));
- return 0;
- }
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/recovery/tests_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/modules/recovery/tests_impl.h
deleted file mode 100644
index 765c7dd81e958c9ca37ee50117b286e90b6c7f7f..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/recovery/tests_impl.h
+++ /dev/null
@@ -1,393 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013-2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_MODULE_RECOVERY_TESTS_
-#define _SECP256K1_MODULE_RECOVERY_TESTS_
-
-static int recovery_test_nonce_function(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
- (void) msg32;
- (void) key32;
- (void) algo16;
- (void) data;
-
- /* On the first run, return 0 to force a second run */
- if (counter == 0) {
- memset(nonce32, 0, 32);
- return 1;
- }
- /* On the second run, return an overflow to force a third run */
- if (counter == 1) {
- memset(nonce32, 0xff, 32);
- return 1;
- }
- /* On the next run, return a valid nonce, but flip a coin as to whether or not to fail signing. */
- memset(nonce32, 1, 32);
- return secp256k1_rand_bits(1);
-}
-
-void test_ecdsa_recovery_api(void) {
- /* Setup contexts that just count errors */
- secp256k1_context *none = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
- secp256k1_context *sign = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
- secp256k1_context *vrfy = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);
- secp256k1_context *both = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
- secp256k1_pubkey pubkey;
- secp256k1_pubkey recpubkey;
- secp256k1_ecdsa_signature normal_sig;
- secp256k1_ecdsa_recoverable_signature recsig;
- unsigned char privkey[32] = { 1 };
- unsigned char message[32] = { 2 };
- int32_t ecount = 0;
- int recid = 0;
- unsigned char sig[74];
- unsigned char zero_privkey[32] = { 0 };
- unsigned char over_privkey[32] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
-
- secp256k1_context_set_error_callback(none, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_error_callback(sign, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_error_callback(vrfy, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_error_callback(both, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(none, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(sign, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(vrfy, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(both, counting_illegal_callback_fn, &ecount);
-
- /* Construct and verify corresponding public key. */
- CHECK(secp256k1_ec_seckey_verify(ctx, privkey) == 1);
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, privkey) == 1);
-
- /* Check bad contexts and NULLs for signing */
- ecount = 0;
- CHECK(secp256k1_ecdsa_sign_recoverable(none, &recsig, message, privkey, NULL, NULL) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_sign_recoverable(sign, &recsig, message, privkey, NULL, NULL) == 1);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_sign_recoverable(vrfy, &recsig, message, privkey, NULL, NULL) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, privkey, NULL, NULL) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_sign_recoverable(both, NULL, message, privkey, NULL, NULL) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, NULL, privkey, NULL, NULL) == 0);
- CHECK(ecount == 4);
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, NULL, NULL, NULL) == 0);
- CHECK(ecount == 5);
- /* This will fail or succeed randomly, and in either case will not ARG_CHECK failure */
- secp256k1_ecdsa_sign_recoverable(both, &recsig, message, privkey, recovery_test_nonce_function, NULL);
- CHECK(ecount == 5);
- /* These will all fail, but not in ARG_CHECK way */
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, zero_privkey, NULL, NULL) == 0);
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, over_privkey, NULL, NULL) == 0);
- /* This one will succeed. */
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, privkey, NULL, NULL) == 1);
- CHECK(ecount == 5);
-
- /* Check signing with a goofy nonce function */
-
- /* Check bad contexts and NULLs for recovery */
- ecount = 0;
- CHECK(secp256k1_ecdsa_recover(none, &recpubkey, &recsig, message) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_recover(sign, &recpubkey, &recsig, message) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_recover(vrfy, &recpubkey, &recsig, message) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_recover(both, &recpubkey, &recsig, message) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_recover(both, NULL, &recsig, message) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_recover(both, &recpubkey, NULL, message) == 0);
- CHECK(ecount == 4);
- CHECK(secp256k1_ecdsa_recover(both, &recpubkey, &recsig, NULL) == 0);
- CHECK(ecount == 5);
-
- /* Check NULLs for conversion */
- CHECK(secp256k1_ecdsa_sign(both, &normal_sig, message, privkey, NULL, NULL) == 1);
- ecount = 0;
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(both, NULL, &recsig) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(both, &normal_sig, NULL) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(both, &normal_sig, &recsig) == 1);
-
- /* Check NULLs for de/serialization */
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, privkey, NULL, NULL) == 1);
- ecount = 0;
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(both, NULL, &recid, &recsig) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(both, sig, NULL, &recsig) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(both, sig, &recid, NULL) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(both, sig, &recid, &recsig) == 1);
-
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(both, NULL, sig, recid) == 0);
- CHECK(ecount == 4);
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(both, &recsig, NULL, recid) == 0);
- CHECK(ecount == 5);
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(both, &recsig, sig, -1) == 0);
- CHECK(ecount == 6);
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(both, &recsig, sig, 5) == 0);
- CHECK(ecount == 7);
- /* overflow in signature will fail but not affect ecount */
- memcpy(sig, over_privkey, 32);
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(both, &recsig, sig, recid) == 0);
- CHECK(ecount == 7);
-
- /* cleanup */
- secp256k1_context_destroy(none);
- secp256k1_context_destroy(sign);
- secp256k1_context_destroy(vrfy);
- secp256k1_context_destroy(both);
-}
-
-void test_ecdsa_recovery_end_to_end(void) {
- unsigned char extra[32] = {0x00};
- unsigned char privkey[32];
- unsigned char message[32];
- secp256k1_ecdsa_signature signature[5];
- secp256k1_ecdsa_recoverable_signature rsignature[5];
- unsigned char sig[74];
- secp256k1_pubkey pubkey;
- secp256k1_pubkey recpubkey;
- int recid = 0;
-
- /* Generate a random key and message. */
- {
- secp256k1_scalar msg, key;
- random_scalar_order_test(&msg);
- random_scalar_order_test(&key);
- secp256k1_scalar_get_b32(privkey, &key);
- secp256k1_scalar_get_b32(message, &msg);
- }
-
- /* Construct and verify corresponding public key. */
- CHECK(secp256k1_ec_seckey_verify(ctx, privkey) == 1);
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, privkey) == 1);
-
- /* Serialize/parse compact and verify/recover. */
- extra[0] = 0;
- CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[0], message, privkey, NULL, NULL) == 1);
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[0], message, privkey, NULL, NULL) == 1);
- CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[4], message, privkey, NULL, NULL) == 1);
- CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[1], message, privkey, NULL, extra) == 1);
- extra[31] = 1;
- CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[2], message, privkey, NULL, extra) == 1);
- extra[31] = 0;
- extra[0] = 1;
- CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[3], message, privkey, NULL, extra) == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(ctx, sig, &recid, &rsignature[4]) == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(ctx, &signature[4], &rsignature[4]) == 1);
- CHECK(memcmp(&signature[4], &signature[0], 64) == 0);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[4], message, &pubkey) == 1);
- memset(&rsignature[4], 0, sizeof(rsignature[4]));
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsignature[4], sig, recid) == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(ctx, &signature[4], &rsignature[4]) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[4], message, &pubkey) == 1);
- /* Parse compact (with recovery id) and recover. */
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsignature[4], sig, recid) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &recpubkey, &rsignature[4], message) == 1);
- CHECK(memcmp(&pubkey, &recpubkey, sizeof(pubkey)) == 0);
- /* Serialize/destroy/parse signature and verify again. */
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(ctx, sig, &recid, &rsignature[4]) == 1);
- sig[secp256k1_rand_bits(6)] += 1 + secp256k1_rand_int(255);
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsignature[4], sig, recid) == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(ctx, &signature[4], &rsignature[4]) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[4], message, &pubkey) == 0);
- /* Recover again */
- CHECK(secp256k1_ecdsa_recover(ctx, &recpubkey, &rsignature[4], message) == 0 ||
- memcmp(&pubkey, &recpubkey, sizeof(pubkey)) != 0);
-}
-
-/* Tests several edge cases. */
-void test_ecdsa_recovery_edge_cases(void) {
- const unsigned char msg32[32] = {
- 'T', 'h', 'i', 's', ' ', 'i', 's', ' ',
- 'a', ' ', 'v', 'e', 'r', 'y', ' ', 's',
- 'e', 'c', 'r', 'e', 't', ' ', 'm', 'e',
- 's', 's', 'a', 'g', 'e', '.', '.', '.'
- };
- const unsigned char sig64[64] = {
- /* Generated by signing the above message with nonce 'This is the nonce we will use...'
- * and secret key 0 (which is not valid), resulting in recid 0. */
- 0x67, 0xCB, 0x28, 0x5F, 0x9C, 0xD1, 0x94, 0xE8,
- 0x40, 0xD6, 0x29, 0x39, 0x7A, 0xF5, 0x56, 0x96,
- 0x62, 0xFD, 0xE4, 0x46, 0x49, 0x99, 0x59, 0x63,
- 0x17, 0x9A, 0x7D, 0xD1, 0x7B, 0xD2, 0x35, 0x32,
- 0x4B, 0x1B, 0x7D, 0xF3, 0x4C, 0xE1, 0xF6, 0x8E,
- 0x69, 0x4F, 0xF6, 0xF1, 0x1A, 0xC7, 0x51, 0xDD,
- 0x7D, 0xD7, 0x3E, 0x38, 0x7E, 0xE4, 0xFC, 0x86,
- 0x6E, 0x1B, 0xE8, 0xEC, 0xC7, 0xDD, 0x95, 0x57
- };
- secp256k1_pubkey pubkey;
- /* signature (r,s) = (4,4), which can be recovered with all 4 recids. */
- const unsigned char sigb64[64] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
- };
- secp256k1_pubkey pubkeyb;
- secp256k1_ecdsa_recoverable_signature rsig;
- secp256k1_ecdsa_signature sig;
- int recid;
-
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 0));
- CHECK(!secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 1));
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 2));
- CHECK(!secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 3));
- CHECK(!secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
-
- for (recid = 0; recid < 4; recid++) {
- int i;
- int recid2;
- /* (4,4) encoded in DER. */
- unsigned char sigbder[8] = {0x30, 0x06, 0x02, 0x01, 0x04, 0x02, 0x01, 0x04};
- unsigned char sigcder_zr[7] = {0x30, 0x05, 0x02, 0x00, 0x02, 0x01, 0x01};
- unsigned char sigcder_zs[7] = {0x30, 0x05, 0x02, 0x01, 0x01, 0x02, 0x00};
- unsigned char sigbderalt1[39] = {
- 0x30, 0x25, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x04, 0x02, 0x01, 0x04,
- };
- unsigned char sigbderalt2[39] = {
- 0x30, 0x25, 0x02, 0x01, 0x04, 0x02, 0x20, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
- };
- unsigned char sigbderalt3[40] = {
- 0x30, 0x26, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x01, 0x04,
- };
- unsigned char sigbderalt4[40] = {
- 0x30, 0x26, 0x02, 0x01, 0x04, 0x02, 0x21, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
- };
- /* (order + r,4) encoded in DER. */
- unsigned char sigbderlong[40] = {
- 0x30, 0x26, 0x02, 0x21, 0x00, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xBA, 0xAE, 0xDC,
- 0xE6, 0xAF, 0x48, 0xA0, 0x3B, 0xBF, 0xD2, 0x5E,
- 0x8C, 0xD0, 0x36, 0x41, 0x45, 0x02, 0x01, 0x04
- };
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigb64, recid) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyb, &rsig, msg32) == 1);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 1);
- for (recid2 = 0; recid2 < 4; recid2++) {
- secp256k1_pubkey pubkey2b;
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigb64, recid2) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkey2b, &rsig, msg32) == 1);
- /* Verifying with (order + r,4) should always fail. */
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderlong, sizeof(sigbderlong)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
- }
- /* DER parsing tests. */
- /* Zero length r/s. */
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder_zr, sizeof(sigcder_zr)) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder_zs, sizeof(sigcder_zs)) == 0);
- /* Leading zeros. */
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt1, sizeof(sigbderalt1)) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt2, sizeof(sigbderalt2)) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt3, sizeof(sigbderalt3)) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt4, sizeof(sigbderalt4)) == 0);
- sigbderalt3[4] = 1;
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt3, sizeof(sigbderalt3)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
- sigbderalt4[7] = 1;
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt4, sizeof(sigbderalt4)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
- /* Damage signature. */
- sigbder[7]++;
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
- sigbder[7]--;
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, 6) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder) - 1) == 0);
- for(i = 0; i < 8; i++) {
- int c;
- unsigned char orig = sigbder[i];
- /*Try every single-byte change.*/
- for (c = 0; c < 256; c++) {
- if (c == orig ) {
- continue;
- }
- sigbder[i] = c;
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder)) == 0 || secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
- }
- sigbder[i] = orig;
- }
- }
-
- /* Test r/s equal to zero */
- {
- /* (1,1) encoded in DER. */
- unsigned char sigcder[8] = {0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01};
- unsigned char sigc64[64] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- };
- secp256k1_pubkey pubkeyc;
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigc64, 0) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyc, &rsig, msg32) == 1);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder, sizeof(sigcder)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyc) == 1);
- sigcder[4] = 0;
- sigc64[31] = 0;
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigc64, 0) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyb, &rsig, msg32) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder, sizeof(sigcder)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyc) == 0);
- sigcder[4] = 1;
- sigcder[7] = 0;
- sigc64[31] = 1;
- sigc64[63] = 0;
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigc64, 0) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyb, &rsig, msg32) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder, sizeof(sigcder)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyc) == 0);
- }
-}
-
-void run_recovery_tests(void) {
- int i;
- for (i = 0; i < count; i++) {
- test_ecdsa_recovery_api();
- }
- for (i = 0; i < 64*count; i++) {
- test_ecdsa_recovery_end_to_end();
- }
- test_ecdsa_recovery_edge_cases();
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/num.h op-geth/crypto/secp256k1/libsecp256k1/src/num.h
deleted file mode 100644
index eff842200fea1dd239a6dd458d82333ba0be3e76..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/num.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_NUM_
-#define _SECP256K1_NUM_
-
-#ifndef USE_NUM_NONE
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#if defined(USE_NUM_GMP)
-#include "num_gmp.h"
-#else
-#error "Please select num implementation"
-#endif
-
-/** Copy a number. */
-static void secp256k1_num_copy(secp256k1_num *r, const secp256k1_num *a);
-
-/** Convert a number's absolute value to a binary big-endian string.
- * There must be enough place. */
-static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const secp256k1_num *a);
-
-/** Set a number to the value of a binary big-endian string. */
-static void secp256k1_num_set_bin(secp256k1_num *r, const unsigned char *a, unsigned int alen);
-
-/** Compute a modular inverse. The input must be less than the modulus. */
-static void secp256k1_num_mod_inverse(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *m);
-
-/** Compute the jacobi symbol (a|b). b must be positive and odd. */
-static int secp256k1_num_jacobi(const secp256k1_num *a, const secp256k1_num *b);
-
-/** Compare the absolute value of two numbers. */
-static int secp256k1_num_cmp(const secp256k1_num *a, const secp256k1_num *b);
-
-/** Test whether two number are equal (including sign). */
-static int secp256k1_num_eq(const secp256k1_num *a, const secp256k1_num *b);
-
-/** Add two (signed) numbers. */
-static void secp256k1_num_add(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b);
-
-/** Subtract two (signed) numbers. */
-static void secp256k1_num_sub(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b);
-
-/** Multiply two (signed) numbers. */
-static void secp256k1_num_mul(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b);
-
-/** Replace a number by its remainder modulo m. M's sign is ignored. The result is a number between 0 and m-1,
- even if r was negative. */
-static void secp256k1_num_mod(secp256k1_num *r, const secp256k1_num *m);
-
-/** Right-shift the passed number by bits. */
-static void secp256k1_num_shift(secp256k1_num *r, int bits);
-
-/** Check whether a number is zero. */
-static int secp256k1_num_is_zero(const secp256k1_num *a);
-
-/** Check whether a number is one. */
-static int secp256k1_num_is_one(const secp256k1_num *a);
-
-/** Check whether a number is strictly negative. */
-static int secp256k1_num_is_neg(const secp256k1_num *a);
-
-/** Change a number's sign. */
-static void secp256k1_num_negate(secp256k1_num *r);
-
-#endif
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/num_gmp.h op-geth/crypto/secp256k1/libsecp256k1/src/num_gmp.h
deleted file mode 100644
index 7dd813088afc94ab54e2281d17edbc709e4b5c3d..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/num_gmp.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_NUM_REPR_
-#define _SECP256K1_NUM_REPR_
-
-#include <gmp.h>
-
-#define NUM_LIMBS ((256+GMP_NUMB_BITS-1)/GMP_NUMB_BITS)
-
-typedef struct {
- mp_limb_t data[2*NUM_LIMBS];
- int neg;
- int limbs;
-} secp256k1_num;
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/num_gmp_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/num_gmp_impl.h
deleted file mode 100644
index 3a46495eeac7d979a87871ca20ce30c2010a54ce..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/num_gmp_impl.h
+++ /dev/null
@@ -1,288 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_NUM_REPR_IMPL_H_
-#define _SECP256K1_NUM_REPR_IMPL_H_
-
-#include <string.h>
-#include <stdlib.h>
-#include <gmp.h>
-
-#include "util.h"
-#include "num.h"
-
-#ifdef VERIFY
-static void secp256k1_num_sanity(const secp256k1_num *a) {
- VERIFY_CHECK(a->limbs == 1 || (a->limbs > 1 && a->data[a->limbs-1] != 0));
-}
-#else
-#define secp256k1_num_sanity(a) do { } while(0)
-#endif
-
-static void secp256k1_num_copy(secp256k1_num *r, const secp256k1_num *a) {
- *r = *a;
-}
-
-static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const secp256k1_num *a) {
- unsigned char tmp[65];
- int len = 0;
- int shift = 0;
- if (a->limbs>1 || a->data[0] != 0) {
- len = mpn_get_str(tmp, 256, (mp_limb_t*)a->data, a->limbs);
- }
- while (shift < len && tmp[shift] == 0) shift++;
- VERIFY_CHECK(len-shift <= (int)rlen);
- memset(r, 0, rlen - len + shift);
- if (len > shift) {
- memcpy(r + rlen - len + shift, tmp + shift, len - shift);
- }
- memset(tmp, 0, sizeof(tmp));
-}
-
-static void secp256k1_num_set_bin(secp256k1_num *r, const unsigned char *a, unsigned int alen) {
- int len;
- VERIFY_CHECK(alen > 0);
- VERIFY_CHECK(alen <= 64);
- len = mpn_set_str(r->data, a, alen, 256);
- if (len == 0) {
- r->data[0] = 0;
- len = 1;
- }
- VERIFY_CHECK(len <= NUM_LIMBS*2);
- r->limbs = len;
- r->neg = 0;
- while (r->limbs > 1 && r->data[r->limbs-1]==0) {
- r->limbs--;
- }
-}
-
-static void secp256k1_num_add_abs(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
- mp_limb_t c = mpn_add(r->data, a->data, a->limbs, b->data, b->limbs);
- r->limbs = a->limbs;
- if (c != 0) {
- VERIFY_CHECK(r->limbs < 2*NUM_LIMBS);
- r->data[r->limbs++] = c;
- }
-}
-
-static void secp256k1_num_sub_abs(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
- mp_limb_t c = mpn_sub(r->data, a->data, a->limbs, b->data, b->limbs);
- (void)c;
- VERIFY_CHECK(c == 0);
- r->limbs = a->limbs;
- while (r->limbs > 1 && r->data[r->limbs-1]==0) {
- r->limbs--;
- }
-}
-
-static void secp256k1_num_mod(secp256k1_num *r, const secp256k1_num *m) {
- secp256k1_num_sanity(r);
- secp256k1_num_sanity(m);
-
- if (r->limbs >= m->limbs) {
- mp_limb_t t[2*NUM_LIMBS];
- mpn_tdiv_qr(t, r->data, 0, r->data, r->limbs, m->data, m->limbs);
- memset(t, 0, sizeof(t));
- r->limbs = m->limbs;
- while (r->limbs > 1 && r->data[r->limbs-1]==0) {
- r->limbs--;
- }
- }
-
- if (r->neg && (r->limbs > 1 || r->data[0] != 0)) {
- secp256k1_num_sub_abs(r, m, r);
- r->neg = 0;
- }
-}
-
-static void secp256k1_num_mod_inverse(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *m) {
- int i;
- mp_limb_t g[NUM_LIMBS+1];
- mp_limb_t u[NUM_LIMBS+1];
- mp_limb_t v[NUM_LIMBS+1];
- mp_size_t sn;
- mp_size_t gn;
- secp256k1_num_sanity(a);
- secp256k1_num_sanity(m);
-
- /** mpn_gcdext computes: (G,S) = gcdext(U,V), where
- * * G = gcd(U,V)
- * * G = U*S + V*T
- * * U has equal or more limbs than V, and V has no padding
- * If we set U to be (a padded version of) a, and V = m:
- * G = a*S + m*T
- * G = a*S mod m
- * Assuming G=1:
- * S = 1/a mod m
- */
- VERIFY_CHECK(m->limbs <= NUM_LIMBS);
- VERIFY_CHECK(m->data[m->limbs-1] != 0);
- for (i = 0; i < m->limbs; i++) {
- u[i] = (i < a->limbs) ? a->data[i] : 0;
- v[i] = m->data[i];
- }
- sn = NUM_LIMBS+1;
- gn = mpn_gcdext(g, r->data, &sn, u, m->limbs, v, m->limbs);
- (void)gn;
- VERIFY_CHECK(gn == 1);
- VERIFY_CHECK(g[0] == 1);
- r->neg = a->neg ^ m->neg;
- if (sn < 0) {
- mpn_sub(r->data, m->data, m->limbs, r->data, -sn);
- r->limbs = m->limbs;
- while (r->limbs > 1 && r->data[r->limbs-1]==0) {
- r->limbs--;
- }
- } else {
- r->limbs = sn;
- }
- memset(g, 0, sizeof(g));
- memset(u, 0, sizeof(u));
- memset(v, 0, sizeof(v));
-}
-
-static int secp256k1_num_jacobi(const secp256k1_num *a, const secp256k1_num *b) {
- int ret;
- mpz_t ga, gb;
- secp256k1_num_sanity(a);
- secp256k1_num_sanity(b);
- VERIFY_CHECK(!b->neg && (b->limbs > 0) && (b->data[0] & 1));
-
- mpz_inits(ga, gb, NULL);
-
- mpz_import(gb, b->limbs, -1, sizeof(mp_limb_t), 0, 0, b->data);
- mpz_import(ga, a->limbs, -1, sizeof(mp_limb_t), 0, 0, a->data);
- if (a->neg) {
- mpz_neg(ga, ga);
- }
-
- ret = mpz_jacobi(ga, gb);
-
- mpz_clears(ga, gb, NULL);
-
- return ret;
-}
-
-static int secp256k1_num_is_one(const secp256k1_num *a) {
- return (a->limbs == 1 && a->data[0] == 1);
-}
-
-static int secp256k1_num_is_zero(const secp256k1_num *a) {
- return (a->limbs == 1 && a->data[0] == 0);
-}
-
-static int secp256k1_num_is_neg(const secp256k1_num *a) {
- return (a->limbs > 1 || a->data[0] != 0) && a->neg;
-}
-
-static int secp256k1_num_cmp(const secp256k1_num *a, const secp256k1_num *b) {
- if (a->limbs > b->limbs) {
- return 1;
- }
- if (a->limbs < b->limbs) {
- return -1;
- }
- return mpn_cmp(a->data, b->data, a->limbs);
-}
-
-static int secp256k1_num_eq(const secp256k1_num *a, const secp256k1_num *b) {
- if (a->limbs > b->limbs) {
- return 0;
- }
- if (a->limbs < b->limbs) {
- return 0;
- }
- if ((a->neg && !secp256k1_num_is_zero(a)) != (b->neg && !secp256k1_num_is_zero(b))) {
- return 0;
- }
- return mpn_cmp(a->data, b->data, a->limbs) == 0;
-}
-
-static void secp256k1_num_subadd(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b, int bneg) {
- if (!(b->neg ^ bneg ^ a->neg)) { /* a and b have the same sign */
- r->neg = a->neg;
- if (a->limbs >= b->limbs) {
- secp256k1_num_add_abs(r, a, b);
- } else {
- secp256k1_num_add_abs(r, b, a);
- }
- } else {
- if (secp256k1_num_cmp(a, b) > 0) {
- r->neg = a->neg;
- secp256k1_num_sub_abs(r, a, b);
- } else {
- r->neg = b->neg ^ bneg;
- secp256k1_num_sub_abs(r, b, a);
- }
- }
-}
-
-static void secp256k1_num_add(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
- secp256k1_num_sanity(a);
- secp256k1_num_sanity(b);
- secp256k1_num_subadd(r, a, b, 0);
-}
-
-static void secp256k1_num_sub(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
- secp256k1_num_sanity(a);
- secp256k1_num_sanity(b);
- secp256k1_num_subadd(r, a, b, 1);
-}
-
-static void secp256k1_num_mul(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
- mp_limb_t tmp[2*NUM_LIMBS+1];
- secp256k1_num_sanity(a);
- secp256k1_num_sanity(b);
-
- VERIFY_CHECK(a->limbs + b->limbs <= 2*NUM_LIMBS+1);
- if ((a->limbs==1 && a->data[0]==0) || (b->limbs==1 && b->data[0]==0)) {
- r->limbs = 1;
- r->neg = 0;
- r->data[0] = 0;
- return;
- }
- if (a->limbs >= b->limbs) {
- mpn_mul(tmp, a->data, a->limbs, b->data, b->limbs);
- } else {
- mpn_mul(tmp, b->data, b->limbs, a->data, a->limbs);
- }
- r->limbs = a->limbs + b->limbs;
- if (r->limbs > 1 && tmp[r->limbs - 1]==0) {
- r->limbs--;
- }
- VERIFY_CHECK(r->limbs <= 2*NUM_LIMBS);
- mpn_copyi(r->data, tmp, r->limbs);
- r->neg = a->neg ^ b->neg;
- memset(tmp, 0, sizeof(tmp));
-}
-
-static void secp256k1_num_shift(secp256k1_num *r, int bits) {
- if (bits % GMP_NUMB_BITS) {
- /* Shift within limbs. */
- mpn_rshift(r->data, r->data, r->limbs, bits % GMP_NUMB_BITS);
- }
- if (bits >= GMP_NUMB_BITS) {
- int i;
- /* Shift full limbs. */
- for (i = 0; i < r->limbs; i++) {
- int index = i + (bits / GMP_NUMB_BITS);
- if (index < r->limbs && index < 2*NUM_LIMBS) {
- r->data[i] = r->data[index];
- } else {
- r->data[i] = 0;
- }
- }
- }
- while (r->limbs>1 && r->data[r->limbs-1]==0) {
- r->limbs--;
- }
-}
-
-static void secp256k1_num_negate(secp256k1_num *r) {
- r->neg ^= 1;
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/num_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/num_impl.h
deleted file mode 100644
index 0b0e3a072a15ac5ddd1575d1968578c0ffce9400..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/num_impl.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_NUM_IMPL_H_
-#define _SECP256K1_NUM_IMPL_H_
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#include "num.h"
-
-#if defined(USE_NUM_GMP)
-#include "num_gmp_impl.h"
-#elif defined(USE_NUM_NONE)
-/* Nothing. */
-#else
-#error "Please select num implementation"
-#endif
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar.h op-geth/crypto/secp256k1/libsecp256k1/src/scalar.h
deleted file mode 100644
index 27e9d8375e8b0dc9977d8b037fb1b4344d027d4c..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_
-#define _SECP256K1_SCALAR_
-
-#include "num.h"
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#if defined(EXHAUSTIVE_TEST_ORDER)
-#include "scalar_low.h"
-#elif defined(USE_SCALAR_4X64)
-#include "scalar_4x64.h"
-#elif defined(USE_SCALAR_8X32)
-#include "scalar_8x32.h"
-#else
-#error "Please select scalar implementation"
-#endif
-
-/** Clear a scalar to prevent the leak of sensitive data. */
-static void secp256k1_scalar_clear(secp256k1_scalar *r);
-
-/** Access bits from a scalar. All requested bits must belong to the same 32-bit limb. */
-static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count);
-
-/** Access bits from a scalar. Not constant time. */
-static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count);
-
-/** Set a scalar from a big endian byte array. */
-static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *bin, int *overflow);
-
-/** Set a scalar to an unsigned integer. */
-static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v);
-
-/** Convert a scalar to a byte array. */
-static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a);
-
-/** Add two scalars together (modulo the group order). Returns whether it overflowed. */
-static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b);
-
-/** Conditionally add a power of two to a scalar. The result is not allowed to overflow. */
-static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag);
-
-/** Multiply two scalars (modulo the group order). */
-static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b);
-
-/** Shift a scalar right by some amount strictly between 0 and 16, returning
- * the low bits that were shifted off */
-static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n);
-
-/** Compute the square of a scalar (modulo the group order). */
-static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a);
-
-/** Compute the inverse of a scalar (modulo the group order). */
-static void secp256k1_scalar_inverse(secp256k1_scalar *r, const secp256k1_scalar *a);
-
-/** Compute the inverse of a scalar (modulo the group order), without constant-time guarantee. */
-static void secp256k1_scalar_inverse_var(secp256k1_scalar *r, const secp256k1_scalar *a);
-
-/** Compute the complement of a scalar (modulo the group order). */
-static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a);
-
-/** Check whether a scalar equals zero. */
-static int secp256k1_scalar_is_zero(const secp256k1_scalar *a);
-
-/** Check whether a scalar equals one. */
-static int secp256k1_scalar_is_one(const secp256k1_scalar *a);
-
-/** Check whether a scalar, considered as an nonnegative integer, is even. */
-static int secp256k1_scalar_is_even(const secp256k1_scalar *a);
-
-/** Check whether a scalar is higher than the group order divided by 2. */
-static int secp256k1_scalar_is_high(const secp256k1_scalar *a);
-
-/** Conditionally negate a number, in constant time.
- * Returns -1 if the number was negated, 1 otherwise */
-static int secp256k1_scalar_cond_negate(secp256k1_scalar *a, int flag);
-
-#ifndef USE_NUM_NONE
-/** Convert a scalar to a number. */
-static void secp256k1_scalar_get_num(secp256k1_num *r, const secp256k1_scalar *a);
-
-/** Get the order of the group as a number. */
-static void secp256k1_scalar_order_get_num(secp256k1_num *r);
-#endif
-
-/** Compare two scalars. */
-static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b);
-
-#ifdef USE_ENDOMORPHISM
-/** Find r1 and r2 such that r1+r2*2^128 = a. */
-static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a);
-/** Find r1 and r2 such that r1+r2*lambda = a, and r1 and r2 are maximum 128 bits long (see secp256k1_gej_mul_lambda). */
-static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a);
-#endif
-
-/** Multiply a and b (without taking the modulus!), divide by 2**shift, and round to the nearest integer. Shift must be at least 256. */
-static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift);
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_4x64.h op-geth/crypto/secp256k1/libsecp256k1/src/scalar_4x64.h
deleted file mode 100644
index cff406038fbee85395fe88332bdd4fdefab8b8e2..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_4x64.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_
-#define _SECP256K1_SCALAR_REPR_
-
-#include <stdint.h>
-
-/** A scalar modulo the group order of the secp256k1 curve. */
-typedef struct {
- uint64_t d[4];
-} secp256k1_scalar;
-
-#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{((uint64_t)(d1)) << 32 | (d0), ((uint64_t)(d3)) << 32 | (d2), ((uint64_t)(d5)) << 32 | (d4), ((uint64_t)(d7)) << 32 | (d6)}}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_4x64_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/scalar_4x64_impl.h
deleted file mode 100644
index 56e7bd82afd630b107c080b5c96cf50cdbb722f9..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_4x64_impl.h
+++ /dev/null
@@ -1,949 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_
-#define _SECP256K1_SCALAR_REPR_IMPL_H_
-
-/* Limbs of the secp256k1 order. */
-#define SECP256K1_N_0 ((uint64_t)0xBFD25E8CD0364141ULL)
-#define SECP256K1_N_1 ((uint64_t)0xBAAEDCE6AF48A03BULL)
-#define SECP256K1_N_2 ((uint64_t)0xFFFFFFFFFFFFFFFEULL)
-#define SECP256K1_N_3 ((uint64_t)0xFFFFFFFFFFFFFFFFULL)
-
-/* Limbs of 2^256 minus the secp256k1 order. */
-#define SECP256K1_N_C_0 (~SECP256K1_N_0 + 1)
-#define SECP256K1_N_C_1 (~SECP256K1_N_1)
-#define SECP256K1_N_C_2 (1)
-
-/* Limbs of half the secp256k1 order. */
-#define SECP256K1_N_H_0 ((uint64_t)0xDFE92F46681B20A0ULL)
-#define SECP256K1_N_H_1 ((uint64_t)0x5D576E7357A4501DULL)
-#define SECP256K1_N_H_2 ((uint64_t)0xFFFFFFFFFFFFFFFFULL)
-#define SECP256K1_N_H_3 ((uint64_t)0x7FFFFFFFFFFFFFFFULL)
-
-SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) {
- r->d[0] = 0;
- r->d[1] = 0;
- r->d[2] = 0;
- r->d[3] = 0;
-}
-
-SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v) {
- r->d[0] = v;
- r->d[1] = 0;
- r->d[2] = 0;
- r->d[3] = 0;
-}
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- VERIFY_CHECK((offset + count - 1) >> 6 == offset >> 6);
- return (a->d[offset >> 6] >> (offset & 0x3F)) & ((((uint64_t)1) << count) - 1);
-}
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- VERIFY_CHECK(count < 32);
- VERIFY_CHECK(offset + count <= 256);
- if ((offset + count - 1) >> 6 == offset >> 6) {
- return secp256k1_scalar_get_bits(a, offset, count);
- } else {
- VERIFY_CHECK((offset >> 6) + 1 < 4);
- return ((a->d[offset >> 6] >> (offset & 0x3F)) | (a->d[(offset >> 6) + 1] << (64 - (offset & 0x3F)))) & ((((uint64_t)1) << count) - 1);
- }
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar *a) {
- int yes = 0;
- int no = 0;
- no |= (a->d[3] < SECP256K1_N_3); /* No need for a > check. */
- no |= (a->d[2] < SECP256K1_N_2);
- yes |= (a->d[2] > SECP256K1_N_2) & ~no;
- no |= (a->d[1] < SECP256K1_N_1);
- yes |= (a->d[1] > SECP256K1_N_1) & ~no;
- yes |= (a->d[0] >= SECP256K1_N_0) & ~no;
- return yes;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar *r, unsigned int overflow) {
- uint128_t t;
- VERIFY_CHECK(overflow <= 1);
- t = (uint128_t)r->d[0] + overflow * SECP256K1_N_C_0;
- r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)r->d[1] + overflow * SECP256K1_N_C_1;
- r->d[1] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)r->d[2] + overflow * SECP256K1_N_C_2;
- r->d[2] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint64_t)r->d[3];
- r->d[3] = t & 0xFFFFFFFFFFFFFFFFULL;
- return overflow;
-}
-
-static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- int overflow;
- uint128_t t = (uint128_t)a->d[0] + b->d[0];
- r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)a->d[1] + b->d[1];
- r->d[1] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)a->d[2] + b->d[2];
- r->d[2] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)a->d[3] + b->d[3];
- r->d[3] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- overflow = t + secp256k1_scalar_check_overflow(r);
- VERIFY_CHECK(overflow == 0 || overflow == 1);
- secp256k1_scalar_reduce(r, overflow);
- return overflow;
-}
-
-static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag) {
- uint128_t t;
- VERIFY_CHECK(bit < 256);
- bit += ((uint32_t) flag - 1) & 0x100; /* forcing (bit >> 6) > 3 makes this a noop */
- t = (uint128_t)r->d[0] + (((uint64_t)((bit >> 6) == 0)) << (bit & 0x3F));
- r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)r->d[1] + (((uint64_t)((bit >> 6) == 1)) << (bit & 0x3F));
- r->d[1] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)r->d[2] + (((uint64_t)((bit >> 6) == 2)) << (bit & 0x3F));
- r->d[2] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)r->d[3] + (((uint64_t)((bit >> 6) == 3)) << (bit & 0x3F));
- r->d[3] = t & 0xFFFFFFFFFFFFFFFFULL;
-#ifdef VERIFY
- VERIFY_CHECK((t >> 64) == 0);
- VERIFY_CHECK(secp256k1_scalar_check_overflow(r) == 0);
-#endif
-}
-
-static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
- int over;
- r->d[0] = (uint64_t)b32[31] | (uint64_t)b32[30] << 8 | (uint64_t)b32[29] << 16 | (uint64_t)b32[28] << 24 | (uint64_t)b32[27] << 32 | (uint64_t)b32[26] << 40 | (uint64_t)b32[25] << 48 | (uint64_t)b32[24] << 56;
- r->d[1] = (uint64_t)b32[23] | (uint64_t)b32[22] << 8 | (uint64_t)b32[21] << 16 | (uint64_t)b32[20] << 24 | (uint64_t)b32[19] << 32 | (uint64_t)b32[18] << 40 | (uint64_t)b32[17] << 48 | (uint64_t)b32[16] << 56;
- r->d[2] = (uint64_t)b32[15] | (uint64_t)b32[14] << 8 | (uint64_t)b32[13] << 16 | (uint64_t)b32[12] << 24 | (uint64_t)b32[11] << 32 | (uint64_t)b32[10] << 40 | (uint64_t)b32[9] << 48 | (uint64_t)b32[8] << 56;
- r->d[3] = (uint64_t)b32[7] | (uint64_t)b32[6] << 8 | (uint64_t)b32[5] << 16 | (uint64_t)b32[4] << 24 | (uint64_t)b32[3] << 32 | (uint64_t)b32[2] << 40 | (uint64_t)b32[1] << 48 | (uint64_t)b32[0] << 56;
- over = secp256k1_scalar_reduce(r, secp256k1_scalar_check_overflow(r));
- if (overflow) {
- *overflow = over;
- }
-}
-
-static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a) {
- bin[0] = a->d[3] >> 56; bin[1] = a->d[3] >> 48; bin[2] = a->d[3] >> 40; bin[3] = a->d[3] >> 32; bin[4] = a->d[3] >> 24; bin[5] = a->d[3] >> 16; bin[6] = a->d[3] >> 8; bin[7] = a->d[3];
- bin[8] = a->d[2] >> 56; bin[9] = a->d[2] >> 48; bin[10] = a->d[2] >> 40; bin[11] = a->d[2] >> 32; bin[12] = a->d[2] >> 24; bin[13] = a->d[2] >> 16; bin[14] = a->d[2] >> 8; bin[15] = a->d[2];
- bin[16] = a->d[1] >> 56; bin[17] = a->d[1] >> 48; bin[18] = a->d[1] >> 40; bin[19] = a->d[1] >> 32; bin[20] = a->d[1] >> 24; bin[21] = a->d[1] >> 16; bin[22] = a->d[1] >> 8; bin[23] = a->d[1];
- bin[24] = a->d[0] >> 56; bin[25] = a->d[0] >> 48; bin[26] = a->d[0] >> 40; bin[27] = a->d[0] >> 32; bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar *a) {
- return (a->d[0] | a->d[1] | a->d[2] | a->d[3]) == 0;
-}
-
-static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a) {
- uint64_t nonzero = 0xFFFFFFFFFFFFFFFFULL * (secp256k1_scalar_is_zero(a) == 0);
- uint128_t t = (uint128_t)(~a->d[0]) + SECP256K1_N_0 + 1;
- r->d[0] = t & nonzero; t >>= 64;
- t += (uint128_t)(~a->d[1]) + SECP256K1_N_1;
- r->d[1] = t & nonzero; t >>= 64;
- t += (uint128_t)(~a->d[2]) + SECP256K1_N_2;
- r->d[2] = t & nonzero; t >>= 64;
- t += (uint128_t)(~a->d[3]) + SECP256K1_N_3;
- r->d[3] = t & nonzero;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar *a) {
- return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3]) == 0;
-}
-
-static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
- int yes = 0;
- int no = 0;
- no |= (a->d[3] < SECP256K1_N_H_3);
- yes |= (a->d[3] > SECP256K1_N_H_3) & ~no;
- no |= (a->d[2] < SECP256K1_N_H_2) & ~yes; /* No need for a > check. */
- no |= (a->d[1] < SECP256K1_N_H_1) & ~yes;
- yes |= (a->d[1] > SECP256K1_N_H_1) & ~no;
- yes |= (a->d[0] > SECP256K1_N_H_0) & ~no;
- return yes;
-}
-
-static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
- /* If we are flag = 0, mask = 00...00 and this is a no-op;
- * if we are flag = 1, mask = 11...11 and this is identical to secp256k1_scalar_negate */
- uint64_t mask = !flag - 1;
- uint64_t nonzero = (secp256k1_scalar_is_zero(r) != 0) - 1;
- uint128_t t = (uint128_t)(r->d[0] ^ mask) + ((SECP256K1_N_0 + 1) & mask);
- r->d[0] = t & nonzero; t >>= 64;
- t += (uint128_t)(r->d[1] ^ mask) + (SECP256K1_N_1 & mask);
- r->d[1] = t & nonzero; t >>= 64;
- t += (uint128_t)(r->d[2] ^ mask) + (SECP256K1_N_2 & mask);
- r->d[2] = t & nonzero; t >>= 64;
- t += (uint128_t)(r->d[3] ^ mask) + (SECP256K1_N_3 & mask);
- r->d[3] = t & nonzero;
- return 2 * (mask == 0) - 1;
-}
-
-/* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
-
-/** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define muladd(a,b) { \
- uint64_t tl, th; \
- { \
- uint128_t t = (uint128_t)a * b; \
- th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \
- tl = t; \
- } \
- c0 += tl; /* overflow is handled on the next line */ \
- th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \
- c1 += th; /* overflow is handled on the next line */ \
- c2 += (c1 < th) ? 1 : 0; /* never overflows by contract (verified in the next line) */ \
- VERIFY_CHECK((c1 >= th) || (c2 != 0)); \
-}
-
-/** Add a*b to the number defined by (c0,c1). c1 must never overflow. */
-#define muladd_fast(a,b) { \
- uint64_t tl, th; \
- { \
- uint128_t t = (uint128_t)a * b; \
- th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \
- tl = t; \
- } \
- c0 += tl; /* overflow is handled on the next line */ \
- th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \
- c1 += th; /* never overflows by contract (verified in the next line) */ \
- VERIFY_CHECK(c1 >= th); \
-}
-
-/** Add 2*a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define muladd2(a,b) { \
- uint64_t tl, th, th2, tl2; \
- { \
- uint128_t t = (uint128_t)a * b; \
- th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \
- tl = t; \
- } \
- th2 = th + th; /* at most 0xFFFFFFFFFFFFFFFE (in case th was 0x7FFFFFFFFFFFFFFF) */ \
- c2 += (th2 < th) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((th2 >= th) || (c2 != 0)); \
- tl2 = tl + tl; /* at most 0xFFFFFFFFFFFFFFFE (in case the lowest 63 bits of tl were 0x7FFFFFFFFFFFFFFF) */ \
- th2 += (tl2 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \
- c0 += tl2; /* overflow is handled on the next line */ \
- th2 += (c0 < tl2) ? 1 : 0; /* second overflow is handled on the next line */ \
- c2 += (c0 < tl2) & (th2 == 0); /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); \
- c1 += th2; /* overflow is handled on the next line */ \
- c2 += (c1 < th2) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c1 >= th2) || (c2 != 0)); \
-}
-
-/** Add a to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define sumadd(a) { \
- unsigned int over; \
- c0 += (a); /* overflow is handled on the next line */ \
- over = (c0 < (a)) ? 1 : 0; \
- c1 += over; /* overflow is handled on the next line */ \
- c2 += (c1 < over) ? 1 : 0; /* never overflows by contract */ \
-}
-
-/** Add a to the number defined by (c0,c1). c1 must never overflow, c2 must be zero. */
-#define sumadd_fast(a) { \
- c0 += (a); /* overflow is handled on the next line */ \
- c1 += (c0 < (a)) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c1 != 0) | (c0 >= (a))); \
- VERIFY_CHECK(c2 == 0); \
-}
-
-/** Extract the lowest 64 bits of (c0,c1,c2) into n, and left shift the number 64 bits. */
-#define extract(n) { \
- (n) = c0; \
- c0 = c1; \
- c1 = c2; \
- c2 = 0; \
-}
-
-/** Extract the lowest 64 bits of (c0,c1,c2) into n, and left shift the number 64 bits. c2 is required to be zero. */
-#define extract_fast(n) { \
- (n) = c0; \
- c0 = c1; \
- c1 = 0; \
- VERIFY_CHECK(c2 == 0); \
-}
-
-static void secp256k1_scalar_reduce_512(secp256k1_scalar *r, const uint64_t *l) {
-#ifdef USE_ASM_X86_64
- /* Reduce 512 bits into 385. */
- uint64_t m0, m1, m2, m3, m4, m5, m6;
- uint64_t p0, p1, p2, p3, p4;
- uint64_t c;
-
- __asm__ __volatile__(
- /* Preload. */
- "movq 32(%%rsi), %%r11\n"
- "movq 40(%%rsi), %%r12\n"
- "movq 48(%%rsi), %%r13\n"
- "movq 56(%%rsi), %%r14\n"
- /* Initialize r8,r9,r10 */
- "movq 0(%%rsi), %%r8\n"
- "xorq %%r9, %%r9\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9) += n0 * c0 */
- "movq %8, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- /* extract m0 */
- "movq %%r8, %q0\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10) += l1 */
- "addq 8(%%rsi), %%r9\n"
- "adcq $0, %%r10\n"
- /* (r9,r10,r8) += n1 * c0 */
- "movq %8, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += n0 * c1 */
- "movq %9, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* extract m1 */
- "movq %%r9, %q1\n"
- "xorq %%r9, %%r9\n"
- /* (r10,r8,r9) += l2 */
- "addq 16(%%rsi), %%r10\n"
- "adcq $0, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += n2 * c0 */
- "movq %8, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += n1 * c1 */
- "movq %9, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += n0 */
- "addq %%r11, %%r10\n"
- "adcq $0, %%r8\n"
- "adcq $0, %%r9\n"
- /* extract m2 */
- "movq %%r10, %q2\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9,r10) += l3 */
- "addq 24(%%rsi), %%r8\n"
- "adcq $0, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += n3 * c0 */
- "movq %8, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += n2 * c1 */
- "movq %9, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += n1 */
- "addq %%r12, %%r8\n"
- "adcq $0, %%r9\n"
- "adcq $0, %%r10\n"
- /* extract m3 */
- "movq %%r8, %q3\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10,r8) += n3 * c1 */
- "movq %9, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += n2 */
- "addq %%r13, %%r9\n"
- "adcq $0, %%r10\n"
- "adcq $0, %%r8\n"
- /* extract m4 */
- "movq %%r9, %q4\n"
- /* (r10,r8) += n3 */
- "addq %%r14, %%r10\n"
- "adcq $0, %%r8\n"
- /* extract m5 */
- "movq %%r10, %q5\n"
- /* extract m6 */
- "movq %%r8, %q6\n"
- : "=g"(m0), "=g"(m1), "=g"(m2), "=g"(m3), "=g"(m4), "=g"(m5), "=g"(m6)
- : "S"(l), "n"(SECP256K1_N_C_0), "n"(SECP256K1_N_C_1)
- : "rax", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "cc");
-
- /* Reduce 385 bits into 258. */
- __asm__ __volatile__(
- /* Preload */
- "movq %q9, %%r11\n"
- "movq %q10, %%r12\n"
- "movq %q11, %%r13\n"
- /* Initialize (r8,r9,r10) */
- "movq %q5, %%r8\n"
- "xorq %%r9, %%r9\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9) += m4 * c0 */
- "movq %12, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- /* extract p0 */
- "movq %%r8, %q0\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10) += m1 */
- "addq %q6, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r9,r10,r8) += m5 * c0 */
- "movq %12, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += m4 * c1 */
- "movq %13, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* extract p1 */
- "movq %%r9, %q1\n"
- "xorq %%r9, %%r9\n"
- /* (r10,r8,r9) += m2 */
- "addq %q7, %%r10\n"
- "adcq $0, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += m6 * c0 */
- "movq %12, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += m5 * c1 */
- "movq %13, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += m4 */
- "addq %%r11, %%r10\n"
- "adcq $0, %%r8\n"
- "adcq $0, %%r9\n"
- /* extract p2 */
- "movq %%r10, %q2\n"
- /* (r8,r9) += m3 */
- "addq %q8, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r8,r9) += m6 * c1 */
- "movq %13, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- /* (r8,r9) += m5 */
- "addq %%r12, %%r8\n"
- "adcq $0, %%r9\n"
- /* extract p3 */
- "movq %%r8, %q3\n"
- /* (r9) += m6 */
- "addq %%r13, %%r9\n"
- /* extract p4 */
- "movq %%r9, %q4\n"
- : "=&g"(p0), "=&g"(p1), "=&g"(p2), "=g"(p3), "=g"(p4)
- : "g"(m0), "g"(m1), "g"(m2), "g"(m3), "g"(m4), "g"(m5), "g"(m6), "n"(SECP256K1_N_C_0), "n"(SECP256K1_N_C_1)
- : "rax", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "cc");
-
- /* Reduce 258 bits into 256. */
- __asm__ __volatile__(
- /* Preload */
- "movq %q5, %%r10\n"
- /* (rax,rdx) = p4 * c0 */
- "movq %7, %%rax\n"
- "mulq %%r10\n"
- /* (rax,rdx) += p0 */
- "addq %q1, %%rax\n"
- "adcq $0, %%rdx\n"
- /* extract r0 */
- "movq %%rax, 0(%q6)\n"
- /* Move to (r8,r9) */
- "movq %%rdx, %%r8\n"
- "xorq %%r9, %%r9\n"
- /* (r8,r9) += p1 */
- "addq %q2, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r8,r9) += p4 * c1 */
- "movq %8, %%rax\n"
- "mulq %%r10\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- /* Extract r1 */
- "movq %%r8, 8(%q6)\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r8) += p4 */
- "addq %%r10, %%r9\n"
- "adcq $0, %%r8\n"
- /* (r9,r8) += p2 */
- "addq %q3, %%r9\n"
- "adcq $0, %%r8\n"
- /* Extract r2 */
- "movq %%r9, 16(%q6)\n"
- "xorq %%r9, %%r9\n"
- /* (r8,r9) += p3 */
- "addq %q4, %%r8\n"
- "adcq $0, %%r9\n"
- /* Extract r3 */
- "movq %%r8, 24(%q6)\n"
- /* Extract c */
- "movq %%r9, %q0\n"
- : "=g"(c)
- : "g"(p0), "g"(p1), "g"(p2), "g"(p3), "g"(p4), "D"(r), "n"(SECP256K1_N_C_0), "n"(SECP256K1_N_C_1)
- : "rax", "rdx", "r8", "r9", "r10", "cc", "memory");
-#else
- uint128_t c;
- uint64_t c0, c1, c2;
- uint64_t n0 = l[4], n1 = l[5], n2 = l[6], n3 = l[7];
- uint64_t m0, m1, m2, m3, m4, m5;
- uint32_t m6;
- uint64_t p0, p1, p2, p3;
- uint32_t p4;
-
- /* Reduce 512 bits into 385. */
- /* m[0..6] = l[0..3] + n[0..3] * SECP256K1_N_C. */
- c0 = l[0]; c1 = 0; c2 = 0;
- muladd_fast(n0, SECP256K1_N_C_0);
- extract_fast(m0);
- sumadd_fast(l[1]);
- muladd(n1, SECP256K1_N_C_0);
- muladd(n0, SECP256K1_N_C_1);
- extract(m1);
- sumadd(l[2]);
- muladd(n2, SECP256K1_N_C_0);
- muladd(n1, SECP256K1_N_C_1);
- sumadd(n0);
- extract(m2);
- sumadd(l[3]);
- muladd(n3, SECP256K1_N_C_0);
- muladd(n2, SECP256K1_N_C_1);
- sumadd(n1);
- extract(m3);
- muladd(n3, SECP256K1_N_C_1);
- sumadd(n2);
- extract(m4);
- sumadd_fast(n3);
- extract_fast(m5);
- VERIFY_CHECK(c0 <= 1);
- m6 = c0;
-
- /* Reduce 385 bits into 258. */
- /* p[0..4] = m[0..3] + m[4..6] * SECP256K1_N_C. */
- c0 = m0; c1 = 0; c2 = 0;
- muladd_fast(m4, SECP256K1_N_C_0);
- extract_fast(p0);
- sumadd_fast(m1);
- muladd(m5, SECP256K1_N_C_0);
- muladd(m4, SECP256K1_N_C_1);
- extract(p1);
- sumadd(m2);
- muladd(m6, SECP256K1_N_C_0);
- muladd(m5, SECP256K1_N_C_1);
- sumadd(m4);
- extract(p2);
- sumadd_fast(m3);
- muladd_fast(m6, SECP256K1_N_C_1);
- sumadd_fast(m5);
- extract_fast(p3);
- p4 = c0 + m6;
- VERIFY_CHECK(p4 <= 2);
-
- /* Reduce 258 bits into 256. */
- /* r[0..3] = p[0..3] + p[4] * SECP256K1_N_C. */
- c = p0 + (uint128_t)SECP256K1_N_C_0 * p4;
- r->d[0] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
- c += p1 + (uint128_t)SECP256K1_N_C_1 * p4;
- r->d[1] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
- c += p2 + (uint128_t)p4;
- r->d[2] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
- c += p3;
- r->d[3] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
-#endif
-
- /* Final reduction of r. */
- secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
-}
-
-static void secp256k1_scalar_mul_512(uint64_t l[8], const secp256k1_scalar *a, const secp256k1_scalar *b) {
-#ifdef USE_ASM_X86_64
- const uint64_t *pb = b->d;
- __asm__ __volatile__(
- /* Preload */
- "movq 0(%%rdi), %%r15\n"
- "movq 8(%%rdi), %%rbx\n"
- "movq 16(%%rdi), %%rcx\n"
- "movq 0(%%rdx), %%r11\n"
- "movq 8(%%rdx), %%r12\n"
- "movq 16(%%rdx), %%r13\n"
- "movq 24(%%rdx), %%r14\n"
- /* (rax,rdx) = a0 * b0 */
- "movq %%r15, %%rax\n"
- "mulq %%r11\n"
- /* Extract l0 */
- "movq %%rax, 0(%%rsi)\n"
- /* (r8,r9,r10) = (rdx) */
- "movq %%rdx, %%r8\n"
- "xorq %%r9, %%r9\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9,r10) += a0 * b1 */
- "movq %%r15, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += a1 * b0 */
- "movq %%rbx, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* Extract l1 */
- "movq %%r8, 8(%%rsi)\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10,r8) += a0 * b2 */
- "movq %%r15, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += a1 * b1 */
- "movq %%rbx, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += a2 * b0 */
- "movq %%rcx, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* Extract l2 */
- "movq %%r9, 16(%%rsi)\n"
- "xorq %%r9, %%r9\n"
- /* (r10,r8,r9) += a0 * b3 */
- "movq %%r15, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* Preload a3 */
- "movq 24(%%rdi), %%r15\n"
- /* (r10,r8,r9) += a1 * b2 */
- "movq %%rbx, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += a2 * b1 */
- "movq %%rcx, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += a3 * b0 */
- "movq %%r15, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* Extract l3 */
- "movq %%r10, 24(%%rsi)\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9,r10) += a1 * b3 */
- "movq %%rbx, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += a2 * b2 */
- "movq %%rcx, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += a3 * b1 */
- "movq %%r15, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* Extract l4 */
- "movq %%r8, 32(%%rsi)\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10,r8) += a2 * b3 */
- "movq %%rcx, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += a3 * b2 */
- "movq %%r15, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* Extract l5 */
- "movq %%r9, 40(%%rsi)\n"
- /* (r10,r8) += a3 * b3 */
- "movq %%r15, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- /* Extract l6 */
- "movq %%r10, 48(%%rsi)\n"
- /* Extract l7 */
- "movq %%r8, 56(%%rsi)\n"
- : "+d"(pb)
- : "S"(l), "D"(a->d)
- : "rax", "rbx", "rcx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "cc", "memory");
-#else
- /* 160 bit accumulator. */
- uint64_t c0 = 0, c1 = 0;
- uint32_t c2 = 0;
-
- /* l[0..7] = a[0..3] * b[0..3]. */
- muladd_fast(a->d[0], b->d[0]);
- extract_fast(l[0]);
- muladd(a->d[0], b->d[1]);
- muladd(a->d[1], b->d[0]);
- extract(l[1]);
- muladd(a->d[0], b->d[2]);
- muladd(a->d[1], b->d[1]);
- muladd(a->d[2], b->d[0]);
- extract(l[2]);
- muladd(a->d[0], b->d[3]);
- muladd(a->d[1], b->d[2]);
- muladd(a->d[2], b->d[1]);
- muladd(a->d[3], b->d[0]);
- extract(l[3]);
- muladd(a->d[1], b->d[3]);
- muladd(a->d[2], b->d[2]);
- muladd(a->d[3], b->d[1]);
- extract(l[4]);
- muladd(a->d[2], b->d[3]);
- muladd(a->d[3], b->d[2]);
- extract(l[5]);
- muladd_fast(a->d[3], b->d[3]);
- extract_fast(l[6]);
- VERIFY_CHECK(c1 == 0);
- l[7] = c0;
-#endif
-}
-
-static void secp256k1_scalar_sqr_512(uint64_t l[8], const secp256k1_scalar *a) {
-#ifdef USE_ASM_X86_64
- __asm__ __volatile__(
- /* Preload */
- "movq 0(%%rdi), %%r11\n"
- "movq 8(%%rdi), %%r12\n"
- "movq 16(%%rdi), %%r13\n"
- "movq 24(%%rdi), %%r14\n"
- /* (rax,rdx) = a0 * a0 */
- "movq %%r11, %%rax\n"
- "mulq %%r11\n"
- /* Extract l0 */
- "movq %%rax, 0(%%rsi)\n"
- /* (r8,r9,r10) = (rdx,0) */
- "movq %%rdx, %%r8\n"
- "xorq %%r9, %%r9\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9,r10) += 2 * a0 * a1 */
- "movq %%r11, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* Extract l1 */
- "movq %%r8, 8(%%rsi)\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10,r8) += 2 * a0 * a2 */
- "movq %%r11, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += a1 * a1 */
- "movq %%r12, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* Extract l2 */
- "movq %%r9, 16(%%rsi)\n"
- "xorq %%r9, %%r9\n"
- /* (r10,r8,r9) += 2 * a0 * a3 */
- "movq %%r11, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += 2 * a1 * a2 */
- "movq %%r12, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* Extract l3 */
- "movq %%r10, 24(%%rsi)\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9,r10) += 2 * a1 * a3 */
- "movq %%r12, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += a2 * a2 */
- "movq %%r13, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* Extract l4 */
- "movq %%r8, 32(%%rsi)\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10,r8) += 2 * a2 * a3 */
- "movq %%r13, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* Extract l5 */
- "movq %%r9, 40(%%rsi)\n"
- /* (r10,r8) += a3 * a3 */
- "movq %%r14, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- /* Extract l6 */
- "movq %%r10, 48(%%rsi)\n"
- /* Extract l7 */
- "movq %%r8, 56(%%rsi)\n"
- :
- : "S"(l), "D"(a->d)
- : "rax", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "cc", "memory");
-#else
- /* 160 bit accumulator. */
- uint64_t c0 = 0, c1 = 0;
- uint32_t c2 = 0;
-
- /* l[0..7] = a[0..3] * b[0..3]. */
- muladd_fast(a->d[0], a->d[0]);
- extract_fast(l[0]);
- muladd2(a->d[0], a->d[1]);
- extract(l[1]);
- muladd2(a->d[0], a->d[2]);
- muladd(a->d[1], a->d[1]);
- extract(l[2]);
- muladd2(a->d[0], a->d[3]);
- muladd2(a->d[1], a->d[2]);
- extract(l[3]);
- muladd2(a->d[1], a->d[3]);
- muladd(a->d[2], a->d[2]);
- extract(l[4]);
- muladd2(a->d[2], a->d[3]);
- extract(l[5]);
- muladd_fast(a->d[3], a->d[3]);
- extract_fast(l[6]);
- VERIFY_CHECK(c1 == 0);
- l[7] = c0;
-#endif
-}
-
-#undef sumadd
-#undef sumadd_fast
-#undef muladd
-#undef muladd_fast
-#undef muladd2
-#undef extract
-#undef extract_fast
-
-static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- uint64_t l[8];
- secp256k1_scalar_mul_512(l, a, b);
- secp256k1_scalar_reduce_512(r, l);
-}
-
-static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
- int ret;
- VERIFY_CHECK(n > 0);
- VERIFY_CHECK(n < 16);
- ret = r->d[0] & ((1 << n) - 1);
- r->d[0] = (r->d[0] >> n) + (r->d[1] << (64 - n));
- r->d[1] = (r->d[1] >> n) + (r->d[2] << (64 - n));
- r->d[2] = (r->d[2] >> n) + (r->d[3] << (64 - n));
- r->d[3] = (r->d[3] >> n);
- return ret;
-}
-
-static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a) {
- uint64_t l[8];
- secp256k1_scalar_sqr_512(l, a);
- secp256k1_scalar_reduce_512(r, l);
-}
-
-#ifdef USE_ENDOMORPHISM
-static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
- r1->d[0] = a->d[0];
- r1->d[1] = a->d[1];
- r1->d[2] = 0;
- r1->d[3] = 0;
- r2->d[0] = a->d[2];
- r2->d[1] = a->d[3];
- r2->d[2] = 0;
- r2->d[3] = 0;
-}
-#endif
-
-SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b) {
- return ((a->d[0] ^ b->d[0]) | (a->d[1] ^ b->d[1]) | (a->d[2] ^ b->d[2]) | (a->d[3] ^ b->d[3])) == 0;
-}
-
-SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift) {
- uint64_t l[8];
- unsigned int shiftlimbs;
- unsigned int shiftlow;
- unsigned int shifthigh;
- VERIFY_CHECK(shift >= 256);
- secp256k1_scalar_mul_512(l, a, b);
- shiftlimbs = shift >> 6;
- shiftlow = shift & 0x3F;
- shifthigh = 64 - shiftlow;
- r->d[0] = shift < 512 ? (l[0 + shiftlimbs] >> shiftlow | (shift < 448 && shiftlow ? (l[1 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[1] = shift < 448 ? (l[1 + shiftlimbs] >> shiftlow | (shift < 384 && shiftlow ? (l[2 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[2] = shift < 384 ? (l[2 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[3 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[3] = shift < 320 ? (l[3 + shiftlimbs] >> shiftlow) : 0;
- secp256k1_scalar_cadd_bit(r, 0, (l[(shift - 1) >> 6] >> ((shift - 1) & 0x3f)) & 1);
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_8x32.h op-geth/crypto/secp256k1/libsecp256k1/src/scalar_8x32.h
deleted file mode 100644
index 1319664f654994b79cf1d50e18eb1fcd8e0026f5..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_8x32.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_
-#define _SECP256K1_SCALAR_REPR_
-
-#include <stdint.h>
-
-/** A scalar modulo the group order of the secp256k1 curve. */
-typedef struct {
- uint32_t d[8];
-} secp256k1_scalar;
-
-#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{(d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7)}}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_8x32_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/scalar_8x32_impl.h
deleted file mode 100644
index aae4f35c0856eb3bd0a1fd35d572a461bb0c7a35..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_8x32_impl.h
+++ /dev/null
@@ -1,721 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_
-#define _SECP256K1_SCALAR_REPR_IMPL_H_
-
-/* Limbs of the secp256k1 order. */
-#define SECP256K1_N_0 ((uint32_t)0xD0364141UL)
-#define SECP256K1_N_1 ((uint32_t)0xBFD25E8CUL)
-#define SECP256K1_N_2 ((uint32_t)0xAF48A03BUL)
-#define SECP256K1_N_3 ((uint32_t)0xBAAEDCE6UL)
-#define SECP256K1_N_4 ((uint32_t)0xFFFFFFFEUL)
-#define SECP256K1_N_5 ((uint32_t)0xFFFFFFFFUL)
-#define SECP256K1_N_6 ((uint32_t)0xFFFFFFFFUL)
-#define SECP256K1_N_7 ((uint32_t)0xFFFFFFFFUL)
-
-/* Limbs of 2^256 minus the secp256k1 order. */
-#define SECP256K1_N_C_0 (~SECP256K1_N_0 + 1)
-#define SECP256K1_N_C_1 (~SECP256K1_N_1)
-#define SECP256K1_N_C_2 (~SECP256K1_N_2)
-#define SECP256K1_N_C_3 (~SECP256K1_N_3)
-#define SECP256K1_N_C_4 (1)
-
-/* Limbs of half the secp256k1 order. */
-#define SECP256K1_N_H_0 ((uint32_t)0x681B20A0UL)
-#define SECP256K1_N_H_1 ((uint32_t)0xDFE92F46UL)
-#define SECP256K1_N_H_2 ((uint32_t)0x57A4501DUL)
-#define SECP256K1_N_H_3 ((uint32_t)0x5D576E73UL)
-#define SECP256K1_N_H_4 ((uint32_t)0xFFFFFFFFUL)
-#define SECP256K1_N_H_5 ((uint32_t)0xFFFFFFFFUL)
-#define SECP256K1_N_H_6 ((uint32_t)0xFFFFFFFFUL)
-#define SECP256K1_N_H_7 ((uint32_t)0x7FFFFFFFUL)
-
-SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) {
- r->d[0] = 0;
- r->d[1] = 0;
- r->d[2] = 0;
- r->d[3] = 0;
- r->d[4] = 0;
- r->d[5] = 0;
- r->d[6] = 0;
- r->d[7] = 0;
-}
-
-SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v) {
- r->d[0] = v;
- r->d[1] = 0;
- r->d[2] = 0;
- r->d[3] = 0;
- r->d[4] = 0;
- r->d[5] = 0;
- r->d[6] = 0;
- r->d[7] = 0;
-}
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- VERIFY_CHECK((offset + count - 1) >> 5 == offset >> 5);
- return (a->d[offset >> 5] >> (offset & 0x1F)) & ((1 << count) - 1);
-}
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- VERIFY_CHECK(count < 32);
- VERIFY_CHECK(offset + count <= 256);
- if ((offset + count - 1) >> 5 == offset >> 5) {
- return secp256k1_scalar_get_bits(a, offset, count);
- } else {
- VERIFY_CHECK((offset >> 5) + 1 < 8);
- return ((a->d[offset >> 5] >> (offset & 0x1F)) | (a->d[(offset >> 5) + 1] << (32 - (offset & 0x1F)))) & ((((uint32_t)1) << count) - 1);
- }
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar *a) {
- int yes = 0;
- int no = 0;
- no |= (a->d[7] < SECP256K1_N_7); /* No need for a > check. */
- no |= (a->d[6] < SECP256K1_N_6); /* No need for a > check. */
- no |= (a->d[5] < SECP256K1_N_5); /* No need for a > check. */
- no |= (a->d[4] < SECP256K1_N_4);
- yes |= (a->d[4] > SECP256K1_N_4) & ~no;
- no |= (a->d[3] < SECP256K1_N_3) & ~yes;
- yes |= (a->d[3] > SECP256K1_N_3) & ~no;
- no |= (a->d[2] < SECP256K1_N_2) & ~yes;
- yes |= (a->d[2] > SECP256K1_N_2) & ~no;
- no |= (a->d[1] < SECP256K1_N_1) & ~yes;
- yes |= (a->d[1] > SECP256K1_N_1) & ~no;
- yes |= (a->d[0] >= SECP256K1_N_0) & ~no;
- return yes;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar *r, uint32_t overflow) {
- uint64_t t;
- VERIFY_CHECK(overflow <= 1);
- t = (uint64_t)r->d[0] + overflow * SECP256K1_N_C_0;
- r->d[0] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[1] + overflow * SECP256K1_N_C_1;
- r->d[1] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[2] + overflow * SECP256K1_N_C_2;
- r->d[2] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[3] + overflow * SECP256K1_N_C_3;
- r->d[3] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[4] + overflow * SECP256K1_N_C_4;
- r->d[4] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[5];
- r->d[5] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[6];
- r->d[6] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[7];
- r->d[7] = t & 0xFFFFFFFFUL;
- return overflow;
-}
-
-static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- int overflow;
- uint64_t t = (uint64_t)a->d[0] + b->d[0];
- r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[1] + b->d[1];
- r->d[1] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[2] + b->d[2];
- r->d[2] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[3] + b->d[3];
- r->d[3] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[4] + b->d[4];
- r->d[4] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[5] + b->d[5];
- r->d[5] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[6] + b->d[6];
- r->d[6] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[7] + b->d[7];
- r->d[7] = t & 0xFFFFFFFFULL; t >>= 32;
- overflow = t + secp256k1_scalar_check_overflow(r);
- VERIFY_CHECK(overflow == 0 || overflow == 1);
- secp256k1_scalar_reduce(r, overflow);
- return overflow;
-}
-
-static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag) {
- uint64_t t;
- VERIFY_CHECK(bit < 256);
- bit += ((uint32_t) flag - 1) & 0x100; /* forcing (bit >> 5) > 7 makes this a noop */
- t = (uint64_t)r->d[0] + (((uint32_t)((bit >> 5) == 0)) << (bit & 0x1F));
- r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[1] + (((uint32_t)((bit >> 5) == 1)) << (bit & 0x1F));
- r->d[1] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[2] + (((uint32_t)((bit >> 5) == 2)) << (bit & 0x1F));
- r->d[2] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[3] + (((uint32_t)((bit >> 5) == 3)) << (bit & 0x1F));
- r->d[3] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[4] + (((uint32_t)((bit >> 5) == 4)) << (bit & 0x1F));
- r->d[4] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[5] + (((uint32_t)((bit >> 5) == 5)) << (bit & 0x1F));
- r->d[5] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[6] + (((uint32_t)((bit >> 5) == 6)) << (bit & 0x1F));
- r->d[6] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[7] + (((uint32_t)((bit >> 5) == 7)) << (bit & 0x1F));
- r->d[7] = t & 0xFFFFFFFFULL;
-#ifdef VERIFY
- VERIFY_CHECK((t >> 32) == 0);
- VERIFY_CHECK(secp256k1_scalar_check_overflow(r) == 0);
-#endif
-}
-
-static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
- int over;
- r->d[0] = (uint32_t)b32[31] | (uint32_t)b32[30] << 8 | (uint32_t)b32[29] << 16 | (uint32_t)b32[28] << 24;
- r->d[1] = (uint32_t)b32[27] | (uint32_t)b32[26] << 8 | (uint32_t)b32[25] << 16 | (uint32_t)b32[24] << 24;
- r->d[2] = (uint32_t)b32[23] | (uint32_t)b32[22] << 8 | (uint32_t)b32[21] << 16 | (uint32_t)b32[20] << 24;
- r->d[3] = (uint32_t)b32[19] | (uint32_t)b32[18] << 8 | (uint32_t)b32[17] << 16 | (uint32_t)b32[16] << 24;
- r->d[4] = (uint32_t)b32[15] | (uint32_t)b32[14] << 8 | (uint32_t)b32[13] << 16 | (uint32_t)b32[12] << 24;
- r->d[5] = (uint32_t)b32[11] | (uint32_t)b32[10] << 8 | (uint32_t)b32[9] << 16 | (uint32_t)b32[8] << 24;
- r->d[6] = (uint32_t)b32[7] | (uint32_t)b32[6] << 8 | (uint32_t)b32[5] << 16 | (uint32_t)b32[4] << 24;
- r->d[7] = (uint32_t)b32[3] | (uint32_t)b32[2] << 8 | (uint32_t)b32[1] << 16 | (uint32_t)b32[0] << 24;
- over = secp256k1_scalar_reduce(r, secp256k1_scalar_check_overflow(r));
- if (overflow) {
- *overflow = over;
- }
-}
-
-static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a) {
- bin[0] = a->d[7] >> 24; bin[1] = a->d[7] >> 16; bin[2] = a->d[7] >> 8; bin[3] = a->d[7];
- bin[4] = a->d[6] >> 24; bin[5] = a->d[6] >> 16; bin[6] = a->d[6] >> 8; bin[7] = a->d[6];
- bin[8] = a->d[5] >> 24; bin[9] = a->d[5] >> 16; bin[10] = a->d[5] >> 8; bin[11] = a->d[5];
- bin[12] = a->d[4] >> 24; bin[13] = a->d[4] >> 16; bin[14] = a->d[4] >> 8; bin[15] = a->d[4];
- bin[16] = a->d[3] >> 24; bin[17] = a->d[3] >> 16; bin[18] = a->d[3] >> 8; bin[19] = a->d[3];
- bin[20] = a->d[2] >> 24; bin[21] = a->d[2] >> 16; bin[22] = a->d[2] >> 8; bin[23] = a->d[2];
- bin[24] = a->d[1] >> 24; bin[25] = a->d[1] >> 16; bin[26] = a->d[1] >> 8; bin[27] = a->d[1];
- bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar *a) {
- return (a->d[0] | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
-}
-
-static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a) {
- uint32_t nonzero = 0xFFFFFFFFUL * (secp256k1_scalar_is_zero(a) == 0);
- uint64_t t = (uint64_t)(~a->d[0]) + SECP256K1_N_0 + 1;
- r->d[0] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[1]) + SECP256K1_N_1;
- r->d[1] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[2]) + SECP256K1_N_2;
- r->d[2] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[3]) + SECP256K1_N_3;
- r->d[3] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[4]) + SECP256K1_N_4;
- r->d[4] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[5]) + SECP256K1_N_5;
- r->d[5] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[6]) + SECP256K1_N_6;
- r->d[6] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[7]) + SECP256K1_N_7;
- r->d[7] = t & nonzero;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar *a) {
- return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
-}
-
-static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
- int yes = 0;
- int no = 0;
- no |= (a->d[7] < SECP256K1_N_H_7);
- yes |= (a->d[7] > SECP256K1_N_H_7) & ~no;
- no |= (a->d[6] < SECP256K1_N_H_6) & ~yes; /* No need for a > check. */
- no |= (a->d[5] < SECP256K1_N_H_5) & ~yes; /* No need for a > check. */
- no |= (a->d[4] < SECP256K1_N_H_4) & ~yes; /* No need for a > check. */
- no |= (a->d[3] < SECP256K1_N_H_3) & ~yes;
- yes |= (a->d[3] > SECP256K1_N_H_3) & ~no;
- no |= (a->d[2] < SECP256K1_N_H_2) & ~yes;
- yes |= (a->d[2] > SECP256K1_N_H_2) & ~no;
- no |= (a->d[1] < SECP256K1_N_H_1) & ~yes;
- yes |= (a->d[1] > SECP256K1_N_H_1) & ~no;
- yes |= (a->d[0] > SECP256K1_N_H_0) & ~no;
- return yes;
-}
-
-static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
- /* If we are flag = 0, mask = 00...00 and this is a no-op;
- * if we are flag = 1, mask = 11...11 and this is identical to secp256k1_scalar_negate */
- uint32_t mask = !flag - 1;
- uint32_t nonzero = 0xFFFFFFFFUL * (secp256k1_scalar_is_zero(r) == 0);
- uint64_t t = (uint64_t)(r->d[0] ^ mask) + ((SECP256K1_N_0 + 1) & mask);
- r->d[0] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[1] ^ mask) + (SECP256K1_N_1 & mask);
- r->d[1] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[2] ^ mask) + (SECP256K1_N_2 & mask);
- r->d[2] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[3] ^ mask) + (SECP256K1_N_3 & mask);
- r->d[3] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[4] ^ mask) + (SECP256K1_N_4 & mask);
- r->d[4] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[5] ^ mask) + (SECP256K1_N_5 & mask);
- r->d[5] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[6] ^ mask) + (SECP256K1_N_6 & mask);
- r->d[6] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[7] ^ mask) + (SECP256K1_N_7 & mask);
- r->d[7] = t & nonzero;
- return 2 * (mask == 0) - 1;
-}
-
-
-/* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
-
-/** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define muladd(a,b) { \
- uint32_t tl, th; \
- { \
- uint64_t t = (uint64_t)a * b; \
- th = t >> 32; /* at most 0xFFFFFFFE */ \
- tl = t; \
- } \
- c0 += tl; /* overflow is handled on the next line */ \
- th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
- c1 += th; /* overflow is handled on the next line */ \
- c2 += (c1 < th) ? 1 : 0; /* never overflows by contract (verified in the next line) */ \
- VERIFY_CHECK((c1 >= th) || (c2 != 0)); \
-}
-
-/** Add a*b to the number defined by (c0,c1). c1 must never overflow. */
-#define muladd_fast(a,b) { \
- uint32_t tl, th; \
- { \
- uint64_t t = (uint64_t)a * b; \
- th = t >> 32; /* at most 0xFFFFFFFE */ \
- tl = t; \
- } \
- c0 += tl; /* overflow is handled on the next line */ \
- th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
- c1 += th; /* never overflows by contract (verified in the next line) */ \
- VERIFY_CHECK(c1 >= th); \
-}
-
-/** Add 2*a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define muladd2(a,b) { \
- uint32_t tl, th, th2, tl2; \
- { \
- uint64_t t = (uint64_t)a * b; \
- th = t >> 32; /* at most 0xFFFFFFFE */ \
- tl = t; \
- } \
- th2 = th + th; /* at most 0xFFFFFFFE (in case th was 0x7FFFFFFF) */ \
- c2 += (th2 < th) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((th2 >= th) || (c2 != 0)); \
- tl2 = tl + tl; /* at most 0xFFFFFFFE (in case the lowest 63 bits of tl were 0x7FFFFFFF) */ \
- th2 += (tl2 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
- c0 += tl2; /* overflow is handled on the next line */ \
- th2 += (c0 < tl2) ? 1 : 0; /* second overflow is handled on the next line */ \
- c2 += (c0 < tl2) & (th2 == 0); /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); \
- c1 += th2; /* overflow is handled on the next line */ \
- c2 += (c1 < th2) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c1 >= th2) || (c2 != 0)); \
-}
-
-/** Add a to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define sumadd(a) { \
- unsigned int over; \
- c0 += (a); /* overflow is handled on the next line */ \
- over = (c0 < (a)) ? 1 : 0; \
- c1 += over; /* overflow is handled on the next line */ \
- c2 += (c1 < over) ? 1 : 0; /* never overflows by contract */ \
-}
-
-/** Add a to the number defined by (c0,c1). c1 must never overflow, c2 must be zero. */
-#define sumadd_fast(a) { \
- c0 += (a); /* overflow is handled on the next line */ \
- c1 += (c0 < (a)) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c1 != 0) | (c0 >= (a))); \
- VERIFY_CHECK(c2 == 0); \
-}
-
-/** Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. */
-#define extract(n) { \
- (n) = c0; \
- c0 = c1; \
- c1 = c2; \
- c2 = 0; \
-}
-
-/** Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. c2 is required to be zero. */
-#define extract_fast(n) { \
- (n) = c0; \
- c0 = c1; \
- c1 = 0; \
- VERIFY_CHECK(c2 == 0); \
-}
-
-static void secp256k1_scalar_reduce_512(secp256k1_scalar *r, const uint32_t *l) {
- uint64_t c;
- uint32_t n0 = l[8], n1 = l[9], n2 = l[10], n3 = l[11], n4 = l[12], n5 = l[13], n6 = l[14], n7 = l[15];
- uint32_t m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12;
- uint32_t p0, p1, p2, p3, p4, p5, p6, p7, p8;
-
- /* 96 bit accumulator. */
- uint32_t c0, c1, c2;
-
- /* Reduce 512 bits into 385. */
- /* m[0..12] = l[0..7] + n[0..7] * SECP256K1_N_C. */
- c0 = l[0]; c1 = 0; c2 = 0;
- muladd_fast(n0, SECP256K1_N_C_0);
- extract_fast(m0);
- sumadd_fast(l[1]);
- muladd(n1, SECP256K1_N_C_0);
- muladd(n0, SECP256K1_N_C_1);
- extract(m1);
- sumadd(l[2]);
- muladd(n2, SECP256K1_N_C_0);
- muladd(n1, SECP256K1_N_C_1);
- muladd(n0, SECP256K1_N_C_2);
- extract(m2);
- sumadd(l[3]);
- muladd(n3, SECP256K1_N_C_0);
- muladd(n2, SECP256K1_N_C_1);
- muladd(n1, SECP256K1_N_C_2);
- muladd(n0, SECP256K1_N_C_3);
- extract(m3);
- sumadd(l[4]);
- muladd(n4, SECP256K1_N_C_0);
- muladd(n3, SECP256K1_N_C_1);
- muladd(n2, SECP256K1_N_C_2);
- muladd(n1, SECP256K1_N_C_3);
- sumadd(n0);
- extract(m4);
- sumadd(l[5]);
- muladd(n5, SECP256K1_N_C_0);
- muladd(n4, SECP256K1_N_C_1);
- muladd(n3, SECP256K1_N_C_2);
- muladd(n2, SECP256K1_N_C_3);
- sumadd(n1);
- extract(m5);
- sumadd(l[6]);
- muladd(n6, SECP256K1_N_C_0);
- muladd(n5, SECP256K1_N_C_1);
- muladd(n4, SECP256K1_N_C_2);
- muladd(n3, SECP256K1_N_C_3);
- sumadd(n2);
- extract(m6);
- sumadd(l[7]);
- muladd(n7, SECP256K1_N_C_0);
- muladd(n6, SECP256K1_N_C_1);
- muladd(n5, SECP256K1_N_C_2);
- muladd(n4, SECP256K1_N_C_3);
- sumadd(n3);
- extract(m7);
- muladd(n7, SECP256K1_N_C_1);
- muladd(n6, SECP256K1_N_C_2);
- muladd(n5, SECP256K1_N_C_3);
- sumadd(n4);
- extract(m8);
- muladd(n7, SECP256K1_N_C_2);
- muladd(n6, SECP256K1_N_C_3);
- sumadd(n5);
- extract(m9);
- muladd(n7, SECP256K1_N_C_3);
- sumadd(n6);
- extract(m10);
- sumadd_fast(n7);
- extract_fast(m11);
- VERIFY_CHECK(c0 <= 1);
- m12 = c0;
-
- /* Reduce 385 bits into 258. */
- /* p[0..8] = m[0..7] + m[8..12] * SECP256K1_N_C. */
- c0 = m0; c1 = 0; c2 = 0;
- muladd_fast(m8, SECP256K1_N_C_0);
- extract_fast(p0);
- sumadd_fast(m1);
- muladd(m9, SECP256K1_N_C_0);
- muladd(m8, SECP256K1_N_C_1);
- extract(p1);
- sumadd(m2);
- muladd(m10, SECP256K1_N_C_0);
- muladd(m9, SECP256K1_N_C_1);
- muladd(m8, SECP256K1_N_C_2);
- extract(p2);
- sumadd(m3);
- muladd(m11, SECP256K1_N_C_0);
- muladd(m10, SECP256K1_N_C_1);
- muladd(m9, SECP256K1_N_C_2);
- muladd(m8, SECP256K1_N_C_3);
- extract(p3);
- sumadd(m4);
- muladd(m12, SECP256K1_N_C_0);
- muladd(m11, SECP256K1_N_C_1);
- muladd(m10, SECP256K1_N_C_2);
- muladd(m9, SECP256K1_N_C_3);
- sumadd(m8);
- extract(p4);
- sumadd(m5);
- muladd(m12, SECP256K1_N_C_1);
- muladd(m11, SECP256K1_N_C_2);
- muladd(m10, SECP256K1_N_C_3);
- sumadd(m9);
- extract(p5);
- sumadd(m6);
- muladd(m12, SECP256K1_N_C_2);
- muladd(m11, SECP256K1_N_C_3);
- sumadd(m10);
- extract(p6);
- sumadd_fast(m7);
- muladd_fast(m12, SECP256K1_N_C_3);
- sumadd_fast(m11);
- extract_fast(p7);
- p8 = c0 + m12;
- VERIFY_CHECK(p8 <= 2);
-
- /* Reduce 258 bits into 256. */
- /* r[0..7] = p[0..7] + p[8] * SECP256K1_N_C. */
- c = p0 + (uint64_t)SECP256K1_N_C_0 * p8;
- r->d[0] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p1 + (uint64_t)SECP256K1_N_C_1 * p8;
- r->d[1] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p2 + (uint64_t)SECP256K1_N_C_2 * p8;
- r->d[2] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p3 + (uint64_t)SECP256K1_N_C_3 * p8;
- r->d[3] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p4 + (uint64_t)p8;
- r->d[4] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p5;
- r->d[5] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p6;
- r->d[6] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p7;
- r->d[7] = c & 0xFFFFFFFFUL; c >>= 32;
-
- /* Final reduction of r. */
- secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
-}
-
-static void secp256k1_scalar_mul_512(uint32_t *l, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- /* 96 bit accumulator. */
- uint32_t c0 = 0, c1 = 0, c2 = 0;
-
- /* l[0..15] = a[0..7] * b[0..7]. */
- muladd_fast(a->d[0], b->d[0]);
- extract_fast(l[0]);
- muladd(a->d[0], b->d[1]);
- muladd(a->d[1], b->d[0]);
- extract(l[1]);
- muladd(a->d[0], b->d[2]);
- muladd(a->d[1], b->d[1]);
- muladd(a->d[2], b->d[0]);
- extract(l[2]);
- muladd(a->d[0], b->d[3]);
- muladd(a->d[1], b->d[2]);
- muladd(a->d[2], b->d[1]);
- muladd(a->d[3], b->d[0]);
- extract(l[3]);
- muladd(a->d[0], b->d[4]);
- muladd(a->d[1], b->d[3]);
- muladd(a->d[2], b->d[2]);
- muladd(a->d[3], b->d[1]);
- muladd(a->d[4], b->d[0]);
- extract(l[4]);
- muladd(a->d[0], b->d[5]);
- muladd(a->d[1], b->d[4]);
- muladd(a->d[2], b->d[3]);
- muladd(a->d[3], b->d[2]);
- muladd(a->d[4], b->d[1]);
- muladd(a->d[5], b->d[0]);
- extract(l[5]);
- muladd(a->d[0], b->d[6]);
- muladd(a->d[1], b->d[5]);
- muladd(a->d[2], b->d[4]);
- muladd(a->d[3], b->d[3]);
- muladd(a->d[4], b->d[2]);
- muladd(a->d[5], b->d[1]);
- muladd(a->d[6], b->d[0]);
- extract(l[6]);
- muladd(a->d[0], b->d[7]);
- muladd(a->d[1], b->d[6]);
- muladd(a->d[2], b->d[5]);
- muladd(a->d[3], b->d[4]);
- muladd(a->d[4], b->d[3]);
- muladd(a->d[5], b->d[2]);
- muladd(a->d[6], b->d[1]);
- muladd(a->d[7], b->d[0]);
- extract(l[7]);
- muladd(a->d[1], b->d[7]);
- muladd(a->d[2], b->d[6]);
- muladd(a->d[3], b->d[5]);
- muladd(a->d[4], b->d[4]);
- muladd(a->d[5], b->d[3]);
- muladd(a->d[6], b->d[2]);
- muladd(a->d[7], b->d[1]);
- extract(l[8]);
- muladd(a->d[2], b->d[7]);
- muladd(a->d[3], b->d[6]);
- muladd(a->d[4], b->d[5]);
- muladd(a->d[5], b->d[4]);
- muladd(a->d[6], b->d[3]);
- muladd(a->d[7], b->d[2]);
- extract(l[9]);
- muladd(a->d[3], b->d[7]);
- muladd(a->d[4], b->d[6]);
- muladd(a->d[5], b->d[5]);
- muladd(a->d[6], b->d[4]);
- muladd(a->d[7], b->d[3]);
- extract(l[10]);
- muladd(a->d[4], b->d[7]);
- muladd(a->d[5], b->d[6]);
- muladd(a->d[6], b->d[5]);
- muladd(a->d[7], b->d[4]);
- extract(l[11]);
- muladd(a->d[5], b->d[7]);
- muladd(a->d[6], b->d[6]);
- muladd(a->d[7], b->d[5]);
- extract(l[12]);
- muladd(a->d[6], b->d[7]);
- muladd(a->d[7], b->d[6]);
- extract(l[13]);
- muladd_fast(a->d[7], b->d[7]);
- extract_fast(l[14]);
- VERIFY_CHECK(c1 == 0);
- l[15] = c0;
-}
-
-static void secp256k1_scalar_sqr_512(uint32_t *l, const secp256k1_scalar *a) {
- /* 96 bit accumulator. */
- uint32_t c0 = 0, c1 = 0, c2 = 0;
-
- /* l[0..15] = a[0..7]^2. */
- muladd_fast(a->d[0], a->d[0]);
- extract_fast(l[0]);
- muladd2(a->d[0], a->d[1]);
- extract(l[1]);
- muladd2(a->d[0], a->d[2]);
- muladd(a->d[1], a->d[1]);
- extract(l[2]);
- muladd2(a->d[0], a->d[3]);
- muladd2(a->d[1], a->d[2]);
- extract(l[3]);
- muladd2(a->d[0], a->d[4]);
- muladd2(a->d[1], a->d[3]);
- muladd(a->d[2], a->d[2]);
- extract(l[4]);
- muladd2(a->d[0], a->d[5]);
- muladd2(a->d[1], a->d[4]);
- muladd2(a->d[2], a->d[3]);
- extract(l[5]);
- muladd2(a->d[0], a->d[6]);
- muladd2(a->d[1], a->d[5]);
- muladd2(a->d[2], a->d[4]);
- muladd(a->d[3], a->d[3]);
- extract(l[6]);
- muladd2(a->d[0], a->d[7]);
- muladd2(a->d[1], a->d[6]);
- muladd2(a->d[2], a->d[5]);
- muladd2(a->d[3], a->d[4]);
- extract(l[7]);
- muladd2(a->d[1], a->d[7]);
- muladd2(a->d[2], a->d[6]);
- muladd2(a->d[3], a->d[5]);
- muladd(a->d[4], a->d[4]);
- extract(l[8]);
- muladd2(a->d[2], a->d[7]);
- muladd2(a->d[3], a->d[6]);
- muladd2(a->d[4], a->d[5]);
- extract(l[9]);
- muladd2(a->d[3], a->d[7]);
- muladd2(a->d[4], a->d[6]);
- muladd(a->d[5], a->d[5]);
- extract(l[10]);
- muladd2(a->d[4], a->d[7]);
- muladd2(a->d[5], a->d[6]);
- extract(l[11]);
- muladd2(a->d[5], a->d[7]);
- muladd(a->d[6], a->d[6]);
- extract(l[12]);
- muladd2(a->d[6], a->d[7]);
- extract(l[13]);
- muladd_fast(a->d[7], a->d[7]);
- extract_fast(l[14]);
- VERIFY_CHECK(c1 == 0);
- l[15] = c0;
-}
-
-#undef sumadd
-#undef sumadd_fast
-#undef muladd
-#undef muladd_fast
-#undef muladd2
-#undef extract
-#undef extract_fast
-
-static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- uint32_t l[16];
- secp256k1_scalar_mul_512(l, a, b);
- secp256k1_scalar_reduce_512(r, l);
-}
-
-static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
- int ret;
- VERIFY_CHECK(n > 0);
- VERIFY_CHECK(n < 16);
- ret = r->d[0] & ((1 << n) - 1);
- r->d[0] = (r->d[0] >> n) + (r->d[1] << (32 - n));
- r->d[1] = (r->d[1] >> n) + (r->d[2] << (32 - n));
- r->d[2] = (r->d[2] >> n) + (r->d[3] << (32 - n));
- r->d[3] = (r->d[3] >> n) + (r->d[4] << (32 - n));
- r->d[4] = (r->d[4] >> n) + (r->d[5] << (32 - n));
- r->d[5] = (r->d[5] >> n) + (r->d[6] << (32 - n));
- r->d[6] = (r->d[6] >> n) + (r->d[7] << (32 - n));
- r->d[7] = (r->d[7] >> n);
- return ret;
-}
-
-static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a) {
- uint32_t l[16];
- secp256k1_scalar_sqr_512(l, a);
- secp256k1_scalar_reduce_512(r, l);
-}
-
-#ifdef USE_ENDOMORPHISM
-static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
- r1->d[0] = a->d[0];
- r1->d[1] = a->d[1];
- r1->d[2] = a->d[2];
- r1->d[3] = a->d[3];
- r1->d[4] = 0;
- r1->d[5] = 0;
- r1->d[6] = 0;
- r1->d[7] = 0;
- r2->d[0] = a->d[4];
- r2->d[1] = a->d[5];
- r2->d[2] = a->d[6];
- r2->d[3] = a->d[7];
- r2->d[4] = 0;
- r2->d[5] = 0;
- r2->d[6] = 0;
- r2->d[7] = 0;
-}
-#endif
-
-SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b) {
- return ((a->d[0] ^ b->d[0]) | (a->d[1] ^ b->d[1]) | (a->d[2] ^ b->d[2]) | (a->d[3] ^ b->d[3]) | (a->d[4] ^ b->d[4]) | (a->d[5] ^ b->d[5]) | (a->d[6] ^ b->d[6]) | (a->d[7] ^ b->d[7])) == 0;
-}
-
-SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift) {
- uint32_t l[16];
- unsigned int shiftlimbs;
- unsigned int shiftlow;
- unsigned int shifthigh;
- VERIFY_CHECK(shift >= 256);
- secp256k1_scalar_mul_512(l, a, b);
- shiftlimbs = shift >> 5;
- shiftlow = shift & 0x1F;
- shifthigh = 32 - shiftlow;
- r->d[0] = shift < 512 ? (l[0 + shiftlimbs] >> shiftlow | (shift < 480 && shiftlow ? (l[1 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[1] = shift < 480 ? (l[1 + shiftlimbs] >> shiftlow | (shift < 448 && shiftlow ? (l[2 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[2] = shift < 448 ? (l[2 + shiftlimbs] >> shiftlow | (shift < 416 && shiftlow ? (l[3 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[3] = shift < 416 ? (l[3 + shiftlimbs] >> shiftlow | (shift < 384 && shiftlow ? (l[4 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[4] = shift < 384 ? (l[4 + shiftlimbs] >> shiftlow | (shift < 352 && shiftlow ? (l[5 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[5] = shift < 352 ? (l[5 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[6 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[6] = shift < 320 ? (l[6 + shiftlimbs] >> shiftlow | (shift < 288 && shiftlow ? (l[7 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[7] = shift < 288 ? (l[7 + shiftlimbs] >> shiftlow) : 0;
- secp256k1_scalar_cadd_bit(r, 0, (l[(shift - 1) >> 5] >> ((shift - 1) & 0x1f)) & 1);
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/scalar_impl.h
deleted file mode 100644
index f5b2376407bd3b2338e26b1a0bb84cd3fc91660b..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_impl.h
+++ /dev/null
@@ -1,370 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_IMPL_H_
-#define _SECP256K1_SCALAR_IMPL_H_
-
-#include "group.h"
-#include "scalar.h"
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#if defined(EXHAUSTIVE_TEST_ORDER)
-#include "scalar_low_impl.h"
-#elif defined(USE_SCALAR_4X64)
-#include "scalar_4x64_impl.h"
-#elif defined(USE_SCALAR_8X32)
-#include "scalar_8x32_impl.h"
-#else
-#error "Please select scalar implementation"
-#endif
-
-#ifndef USE_NUM_NONE
-static void secp256k1_scalar_get_num(secp256k1_num *r, const secp256k1_scalar *a) {
- unsigned char c[32];
- secp256k1_scalar_get_b32(c, a);
- secp256k1_num_set_bin(r, c, 32);
-}
-
-/** secp256k1 curve order, see secp256k1_ecdsa_const_order_as_fe in ecdsa_impl.h */
-static void secp256k1_scalar_order_get_num(secp256k1_num *r) {
-#if defined(EXHAUSTIVE_TEST_ORDER)
- static const unsigned char order[32] = {
- 0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,EXHAUSTIVE_TEST_ORDER
- };
-#else
- static const unsigned char order[32] = {
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
- 0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,
- 0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x41
- };
-#endif
- secp256k1_num_set_bin(r, order, 32);
-}
-#endif
-
-static void secp256k1_scalar_inverse(secp256k1_scalar *r, const secp256k1_scalar *x) {
-#if defined(EXHAUSTIVE_TEST_ORDER)
- int i;
- *r = 0;
- for (i = 0; i < EXHAUSTIVE_TEST_ORDER; i++)
- if ((i * *x) % EXHAUSTIVE_TEST_ORDER == 1)
- *r = i;
- /* If this VERIFY_CHECK triggers we were given a noninvertible scalar (and thus
- * have a composite group order; fix it in exhaustive_tests.c). */
- VERIFY_CHECK(*r != 0);
-}
-#else
- secp256k1_scalar *t;
- int i;
- /* First compute x ^ (2^N - 1) for some values of N. */
- secp256k1_scalar x2, x3, x4, x6, x7, x8, x15, x30, x60, x120, x127;
-
- secp256k1_scalar_sqr(&x2, x);
- secp256k1_scalar_mul(&x2, &x2, x);
-
- secp256k1_scalar_sqr(&x3, &x2);
- secp256k1_scalar_mul(&x3, &x3, x);
-
- secp256k1_scalar_sqr(&x4, &x3);
- secp256k1_scalar_mul(&x4, &x4, x);
-
- secp256k1_scalar_sqr(&x6, &x4);
- secp256k1_scalar_sqr(&x6, &x6);
- secp256k1_scalar_mul(&x6, &x6, &x2);
-
- secp256k1_scalar_sqr(&x7, &x6);
- secp256k1_scalar_mul(&x7, &x7, x);
-
- secp256k1_scalar_sqr(&x8, &x7);
- secp256k1_scalar_mul(&x8, &x8, x);
-
- secp256k1_scalar_sqr(&x15, &x8);
- for (i = 0; i < 6; i++) {
- secp256k1_scalar_sqr(&x15, &x15);
- }
- secp256k1_scalar_mul(&x15, &x15, &x7);
-
- secp256k1_scalar_sqr(&x30, &x15);
- for (i = 0; i < 14; i++) {
- secp256k1_scalar_sqr(&x30, &x30);
- }
- secp256k1_scalar_mul(&x30, &x30, &x15);
-
- secp256k1_scalar_sqr(&x60, &x30);
- for (i = 0; i < 29; i++) {
- secp256k1_scalar_sqr(&x60, &x60);
- }
- secp256k1_scalar_mul(&x60, &x60, &x30);
-
- secp256k1_scalar_sqr(&x120, &x60);
- for (i = 0; i < 59; i++) {
- secp256k1_scalar_sqr(&x120, &x120);
- }
- secp256k1_scalar_mul(&x120, &x120, &x60);
-
- secp256k1_scalar_sqr(&x127, &x120);
- for (i = 0; i < 6; i++) {
- secp256k1_scalar_sqr(&x127, &x127);
- }
- secp256k1_scalar_mul(&x127, &x127, &x7);
-
- /* Then accumulate the final result (t starts at x127). */
- t = &x127;
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 4; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 4; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 3; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 4; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 5; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 4; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 5; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x4); /* 1111 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 3; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 4; i++) { /* 000 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 10; i++) { /* 0000000 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 4; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 9; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x8); /* 11111111 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 3; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 3; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 5; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x4); /* 1111 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 5; i++) { /* 000 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 4; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 8; i++) { /* 000000 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 3; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 3; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 6; i++) { /* 00000 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 8; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(r, t, &x6); /* 111111 */
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_even(const secp256k1_scalar *a) {
- return !(a->d[0] & 1);
-}
-#endif
-
-static void secp256k1_scalar_inverse_var(secp256k1_scalar *r, const secp256k1_scalar *x) {
-#if defined(USE_SCALAR_INV_BUILTIN)
- secp256k1_scalar_inverse(r, x);
-#elif defined(USE_SCALAR_INV_NUM)
- unsigned char b[32];
- secp256k1_num n, m;
- secp256k1_scalar t = *x;
- secp256k1_scalar_get_b32(b, &t);
- secp256k1_num_set_bin(&n, b, 32);
- secp256k1_scalar_order_get_num(&m);
- secp256k1_num_mod_inverse(&n, &n, &m);
- secp256k1_num_get_bin(b, 32, &n);
- secp256k1_scalar_set_b32(r, b, NULL);
- /* Verify that the inverse was computed correctly, without GMP code. */
- secp256k1_scalar_mul(&t, &t, r);
- CHECK(secp256k1_scalar_is_one(&t));
-#else
-#error "Please select scalar inverse implementation"
-#endif
-}
-
-#ifdef USE_ENDOMORPHISM
-#if defined(EXHAUSTIVE_TEST_ORDER)
-/**
- * Find k1 and k2 given k, such that k1 + k2 * lambda == k mod n; unlike in the
- * full case we don't bother making k1 and k2 be small, we just want them to be
- * nontrivial to get full test coverage for the exhaustive tests. We therefore
- * (arbitrarily) set k2 = k + 5 and k1 = k - k2 * lambda.
- */
-static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
- *r2 = (*a + 5) % EXHAUSTIVE_TEST_ORDER;
- *r1 = (*a + (EXHAUSTIVE_TEST_ORDER - *r2) * EXHAUSTIVE_TEST_LAMBDA) % EXHAUSTIVE_TEST_ORDER;
-}
-#else
-/**
- * The Secp256k1 curve has an endomorphism, where lambda * (x, y) = (beta * x, y), where
- * lambda is {0x53,0x63,0xad,0x4c,0xc0,0x5c,0x30,0xe0,0xa5,0x26,0x1c,0x02,0x88,0x12,0x64,0x5a,
- * 0x12,0x2e,0x22,0xea,0x20,0x81,0x66,0x78,0xdf,0x02,0x96,0x7c,0x1b,0x23,0xbd,0x72}
- *
- * "Guide to Elliptic Curve Cryptography" (Hankerson, Menezes, Vanstone) gives an algorithm
- * (algorithm 3.74) to find k1 and k2 given k, such that k1 + k2 * lambda == k mod n, and k1
- * and k2 have a small size.
- * It relies on constants a1, b1, a2, b2. These constants for the value of lambda above are:
- *
- * - a1 = {0x30,0x86,0xd2,0x21,0xa7,0xd4,0x6b,0xcd,0xe8,0x6c,0x90,0xe4,0x92,0x84,0xeb,0x15}
- * - b1 = -{0xe4,0x43,0x7e,0xd6,0x01,0x0e,0x88,0x28,0x6f,0x54,0x7f,0xa9,0x0a,0xbf,0xe4,0xc3}
- * - a2 = {0x01,0x14,0xca,0x50,0xf7,0xa8,0xe2,0xf3,0xf6,0x57,0xc1,0x10,0x8d,0x9d,0x44,0xcf,0xd8}
- * - b2 = {0x30,0x86,0xd2,0x21,0xa7,0xd4,0x6b,0xcd,0xe8,0x6c,0x90,0xe4,0x92,0x84,0xeb,0x15}
- *
- * The algorithm then computes c1 = round(b1 * k / n) and c2 = round(b2 * k / n), and gives
- * k1 = k - (c1*a1 + c2*a2) and k2 = -(c1*b1 + c2*b2). Instead, we use modular arithmetic, and
- * compute k1 as k - k2 * lambda, avoiding the need for constants a1 and a2.
- *
- * g1, g2 are precomputed constants used to replace division with a rounded multiplication
- * when decomposing the scalar for an endomorphism-based point multiplication.
- *
- * The possibility of using precomputed estimates is mentioned in "Guide to Elliptic Curve
- * Cryptography" (Hankerson, Menezes, Vanstone) in section 3.5.
- *
- * The derivation is described in the paper "Efficient Software Implementation of Public-Key
- * Cryptography on Sensor Networks Using the MSP430X Microcontroller" (Gouvea, Oliveira, Lopez),
- * Section 4.3 (here we use a somewhat higher-precision estimate):
- * d = a1*b2 - b1*a2
- * g1 = round((2^272)*b2/d)
- * g2 = round((2^272)*b1/d)
- *
- * (Note that 'd' is also equal to the curve order here because [a1,b1] and [a2,b2] are found
- * as outputs of the Extended Euclidean Algorithm on inputs 'order' and 'lambda').
- *
- * The function below splits a in r1 and r2, such that r1 + lambda * r2 == a (mod order).
- */
-
-static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
- secp256k1_scalar c1, c2;
- static const secp256k1_scalar minus_lambda = SECP256K1_SCALAR_CONST(
- 0xAC9C52B3UL, 0x3FA3CF1FUL, 0x5AD9E3FDUL, 0x77ED9BA4UL,
- 0xA880B9FCUL, 0x8EC739C2UL, 0xE0CFC810UL, 0xB51283CFUL
- );
- static const secp256k1_scalar minus_b1 = SECP256K1_SCALAR_CONST(
- 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,
- 0xE4437ED6UL, 0x010E8828UL, 0x6F547FA9UL, 0x0ABFE4C3UL
- );
- static const secp256k1_scalar minus_b2 = SECP256K1_SCALAR_CONST(
- 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL,
- 0x8A280AC5UL, 0x0774346DUL, 0xD765CDA8UL, 0x3DB1562CUL
- );
- static const secp256k1_scalar g1 = SECP256K1_SCALAR_CONST(
- 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00003086UL,
- 0xD221A7D4UL, 0x6BCDE86CUL, 0x90E49284UL, 0xEB153DABUL
- );
- static const secp256k1_scalar g2 = SECP256K1_SCALAR_CONST(
- 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x0000E443UL,
- 0x7ED6010EUL, 0x88286F54UL, 0x7FA90ABFUL, 0xE4C42212UL
- );
- VERIFY_CHECK(r1 != a);
- VERIFY_CHECK(r2 != a);
- /* these _var calls are constant time since the shift amount is constant */
- secp256k1_scalar_mul_shift_var(&c1, a, &g1, 272);
- secp256k1_scalar_mul_shift_var(&c2, a, &g2, 272);
- secp256k1_scalar_mul(&c1, &c1, &minus_b1);
- secp256k1_scalar_mul(&c2, &c2, &minus_b2);
- secp256k1_scalar_add(r2, &c1, &c2);
- secp256k1_scalar_mul(r1, r2, &minus_lambda);
- secp256k1_scalar_add(r1, r1, a);
-}
-#endif
-#endif
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_low.h op-geth/crypto/secp256k1/libsecp256k1/src/scalar_low.h
deleted file mode 100644
index 5574c44c7aeb3c8d41ec626adcb1b6994b6f05ef..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_low.h
+++ /dev/null
@@ -1,15 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_
-#define _SECP256K1_SCALAR_REPR_
-
-#include <stdint.h>
-
-/** A scalar modulo the group order of the secp256k1 curve. */
-typedef uint32_t secp256k1_scalar;
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_low_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/scalar_low_impl.h
deleted file mode 100644
index 4f94441f492a8144ebe579435ead2a66712eea17..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/scalar_low_impl.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_
-#define _SECP256K1_SCALAR_REPR_IMPL_H_
-
-#include "scalar.h"
-
-#include <string.h>
-
-SECP256K1_INLINE static int secp256k1_scalar_is_even(const secp256k1_scalar *a) {
- return !(*a & 1);
-}
-
-SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) { *r = 0; }
-SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v) { *r = v; }
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- if (offset < 32)
- return ((*a >> offset) & ((((uint32_t)1) << count) - 1));
- else
- return 0;
-}
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- return secp256k1_scalar_get_bits(a, offset, count);
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar *a) { return *a >= EXHAUSTIVE_TEST_ORDER; }
-
-static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- *r = (*a + *b) % EXHAUSTIVE_TEST_ORDER;
- return *r < *b;
-}
-
-static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag) {
- if (flag && bit < 32)
- *r += (1 << bit);
-#ifdef VERIFY
- VERIFY_CHECK(secp256k1_scalar_check_overflow(r) == 0);
-#endif
-}
-
-static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
- const int base = 0x100 % EXHAUSTIVE_TEST_ORDER;
- int i;
- *r = 0;
- for (i = 0; i < 32; i++) {
- *r = ((*r * base) + b32[i]) % EXHAUSTIVE_TEST_ORDER;
- }
- /* just deny overflow, it basically always happens */
- if (overflow) *overflow = 0;
-}
-
-static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a) {
- memset(bin, 0, 32);
- bin[28] = *a >> 24; bin[29] = *a >> 16; bin[30] = *a >> 8; bin[31] = *a;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar *a) {
- return *a == 0;
-}
-
-static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a) {
- if (*a == 0) {
- *r = 0;
- } else {
- *r = EXHAUSTIVE_TEST_ORDER - *a;
- }
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar *a) {
- return *a == 1;
-}
-
-static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
- return *a > EXHAUSTIVE_TEST_ORDER / 2;
-}
-
-static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
- if (flag) secp256k1_scalar_negate(r, r);
- return flag ? -1 : 1;
-}
-
-static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- *r = (*a * *b) % EXHAUSTIVE_TEST_ORDER;
-}
-
-static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
- int ret;
- VERIFY_CHECK(n > 0);
- VERIFY_CHECK(n < 16);
- ret = *r & ((1 << n) - 1);
- *r >>= n;
- return ret;
-}
-
-static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a) {
- *r = (*a * *a) % EXHAUSTIVE_TEST_ORDER;
-}
-
-static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
- *r1 = *a;
- *r2 = 0;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b) {
- return *a == *b;
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/secp256k1.c op-geth/crypto/secp256k1/libsecp256k1/src/secp256k1.c
deleted file mode 100755
index 7d637bfad1c5967a1001b2248d71947c76cfbd35..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/secp256k1.c
+++ /dev/null
@@ -1,559 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013-2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#include "include/secp256k1.h"
-
-#include "util.h"
-#include "num_impl.h"
-#include "field_impl.h"
-#include "scalar_impl.h"
-#include "group_impl.h"
-#include "ecmult_impl.h"
-#include "ecmult_const_impl.h"
-#include "ecmult_gen_impl.h"
-#include "ecdsa_impl.h"
-#include "eckey_impl.h"
-#include "hash_impl.h"
-
-#define ARG_CHECK(cond) do { \
- if (EXPECT(!(cond), 0)) { \
- secp256k1_callback_call(&ctx->illegal_callback, #cond); \
- return 0; \
- } \
-} while(0)
-
-static void default_illegal_callback_fn(const char* str, void* data) {
- fprintf(stderr, "[libsecp256k1] illegal argument: %s\n", str);
- abort();
-}
-
-static const secp256k1_callback default_illegal_callback = {
- default_illegal_callback_fn,
- NULL
-};
-
-static void default_error_callback_fn(const char* str, void* data) {
- fprintf(stderr, "[libsecp256k1] internal consistency check failed: %s\n", str);
- abort();
-}
-
-static const secp256k1_callback default_error_callback = {
- default_error_callback_fn,
- NULL
-};
-
-
-struct secp256k1_context_struct {
- secp256k1_ecmult_context ecmult_ctx;
- secp256k1_ecmult_gen_context ecmult_gen_ctx;
- secp256k1_callback illegal_callback;
- secp256k1_callback error_callback;
-};
-
-secp256k1_context* secp256k1_context_create(unsigned int flags) {
- secp256k1_context* ret = (secp256k1_context*)checked_malloc(&default_error_callback, sizeof(secp256k1_context));
- ret->illegal_callback = default_illegal_callback;
- ret->error_callback = default_error_callback;
-
- if (EXPECT((flags & SECP256K1_FLAGS_TYPE_MASK) != SECP256K1_FLAGS_TYPE_CONTEXT, 0)) {
- secp256k1_callback_call(&ret->illegal_callback,
- "Invalid flags");
- free(ret);
- return NULL;
- }
-
- secp256k1_ecmult_context_init(&ret->ecmult_ctx);
- secp256k1_ecmult_gen_context_init(&ret->ecmult_gen_ctx);
-
- if (flags & SECP256K1_FLAGS_BIT_CONTEXT_SIGN) {
- secp256k1_ecmult_gen_context_build(&ret->ecmult_gen_ctx, &ret->error_callback);
- }
- if (flags & SECP256K1_FLAGS_BIT_CONTEXT_VERIFY) {
- secp256k1_ecmult_context_build(&ret->ecmult_ctx, &ret->error_callback);
- }
-
- return ret;
-}
-
-secp256k1_context* secp256k1_context_clone(const secp256k1_context* ctx) {
- secp256k1_context* ret = (secp256k1_context*)checked_malloc(&ctx->error_callback, sizeof(secp256k1_context));
- ret->illegal_callback = ctx->illegal_callback;
- ret->error_callback = ctx->error_callback;
- secp256k1_ecmult_context_clone(&ret->ecmult_ctx, &ctx->ecmult_ctx, &ctx->error_callback);
- secp256k1_ecmult_gen_context_clone(&ret->ecmult_gen_ctx, &ctx->ecmult_gen_ctx, &ctx->error_callback);
- return ret;
-}
-
-void secp256k1_context_destroy(secp256k1_context* ctx) {
- if (ctx != NULL) {
- secp256k1_ecmult_context_clear(&ctx->ecmult_ctx);
- secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx);
-
- free(ctx);
- }
-}
-
-void secp256k1_context_set_illegal_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
- if (fun == NULL) {
- fun = default_illegal_callback_fn;
- }
- ctx->illegal_callback.fn = fun;
- ctx->illegal_callback.data = data;
-}
-
-void secp256k1_context_set_error_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
- if (fun == NULL) {
- fun = default_error_callback_fn;
- }
- ctx->error_callback.fn = fun;
- ctx->error_callback.data = data;
-}
-
-static int secp256k1_pubkey_load(const secp256k1_context* ctx, secp256k1_ge* ge, const secp256k1_pubkey* pubkey) {
- if (sizeof(secp256k1_ge_storage) == 64) {
- /* When the secp256k1_ge_storage type is exactly 64 byte, use its
- * representation inside secp256k1_pubkey, as conversion is very fast.
- * Note that secp256k1_pubkey_save must use the same representation. */
- secp256k1_ge_storage s;
- memcpy(&s, &pubkey->data[0], 64);
- secp256k1_ge_from_storage(ge, &s);
- } else {
- /* Otherwise, fall back to 32-byte big endian for X and Y. */
- secp256k1_fe x, y;
- secp256k1_fe_set_b32(&x, pubkey->data);
- secp256k1_fe_set_b32(&y, pubkey->data + 32);
- secp256k1_ge_set_xy(ge, &x, &y);
- }
- ARG_CHECK(!secp256k1_fe_is_zero(&ge->x));
- return 1;
-}
-
-static void secp256k1_pubkey_save(secp256k1_pubkey* pubkey, secp256k1_ge* ge) {
- if (sizeof(secp256k1_ge_storage) == 64) {
- secp256k1_ge_storage s;
- secp256k1_ge_to_storage(&s, ge);
- memcpy(&pubkey->data[0], &s, 64);
- } else {
- VERIFY_CHECK(!secp256k1_ge_is_infinity(ge));
- secp256k1_fe_normalize_var(&ge->x);
- secp256k1_fe_normalize_var(&ge->y);
- secp256k1_fe_get_b32(pubkey->data, &ge->x);
- secp256k1_fe_get_b32(pubkey->data + 32, &ge->y);
- }
-}
-
-int secp256k1_ec_pubkey_parse(const secp256k1_context* ctx, secp256k1_pubkey* pubkey, const unsigned char *input, size_t inputlen) {
- secp256k1_ge Q;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(pubkey != NULL);
- memset(pubkey, 0, sizeof(*pubkey));
- ARG_CHECK(input != NULL);
- if (!secp256k1_eckey_pubkey_parse(&Q, input, inputlen)) {
- return 0;
- }
- secp256k1_pubkey_save(pubkey, &Q);
- secp256k1_ge_clear(&Q);
- return 1;
-}
-
-int secp256k1_ec_pubkey_serialize(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_pubkey* pubkey, unsigned int flags) {
- secp256k1_ge Q;
- size_t len;
- int ret = 0;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(outputlen != NULL);
- ARG_CHECK(*outputlen >= ((flags & SECP256K1_FLAGS_BIT_COMPRESSION) ? 33 : 65));
- len = *outputlen;
- *outputlen = 0;
- ARG_CHECK(output != NULL);
- memset(output, 0, len);
- ARG_CHECK(pubkey != NULL);
- ARG_CHECK((flags & SECP256K1_FLAGS_TYPE_MASK) == SECP256K1_FLAGS_TYPE_COMPRESSION);
- if (secp256k1_pubkey_load(ctx, &Q, pubkey)) {
- ret = secp256k1_eckey_pubkey_serialize(&Q, output, &len, flags & SECP256K1_FLAGS_BIT_COMPRESSION);
- if (ret) {
- *outputlen = len;
- }
- }
- return ret;
-}
-
-static void secp256k1_ecdsa_signature_load(const secp256k1_context* ctx, secp256k1_scalar* r, secp256k1_scalar* s, const secp256k1_ecdsa_signature* sig) {
- (void)ctx;
- if (sizeof(secp256k1_scalar) == 32) {
- /* When the secp256k1_scalar type is exactly 32 byte, use its
- * representation inside secp256k1_ecdsa_signature, as conversion is very fast.
- * Note that secp256k1_ecdsa_signature_save must use the same representation. */
- memcpy(r, &sig->data[0], 32);
- memcpy(s, &sig->data[32], 32);
- } else {
- secp256k1_scalar_set_b32(r, &sig->data[0], NULL);
- secp256k1_scalar_set_b32(s, &sig->data[32], NULL);
- }
-}
-
-static void secp256k1_ecdsa_signature_save(secp256k1_ecdsa_signature* sig, const secp256k1_scalar* r, const secp256k1_scalar* s) {
- if (sizeof(secp256k1_scalar) == 32) {
- memcpy(&sig->data[0], r, 32);
- memcpy(&sig->data[32], s, 32);
- } else {
- secp256k1_scalar_get_b32(&sig->data[0], r);
- secp256k1_scalar_get_b32(&sig->data[32], s);
- }
-}
-
-int secp256k1_ecdsa_signature_parse_der(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
- secp256k1_scalar r, s;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(sig != NULL);
- ARG_CHECK(input != NULL);
-
- if (secp256k1_ecdsa_sig_parse(&r, &s, input, inputlen)) {
- secp256k1_ecdsa_signature_save(sig, &r, &s);
- return 1;
- } else {
- memset(sig, 0, sizeof(*sig));
- return 0;
- }
-}
-
-int secp256k1_ecdsa_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input64) {
- secp256k1_scalar r, s;
- int ret = 1;
- int overflow = 0;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(sig != NULL);
- ARG_CHECK(input64 != NULL);
-
- secp256k1_scalar_set_b32(&r, &input64[0], &overflow);
- ret &= !overflow;
- secp256k1_scalar_set_b32(&s, &input64[32], &overflow);
- ret &= !overflow;
- if (ret) {
- secp256k1_ecdsa_signature_save(sig, &r, &s);
- } else {
- memset(sig, 0, sizeof(*sig));
- }
- return ret;
-}
-
-int secp256k1_ecdsa_signature_serialize_der(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_ecdsa_signature* sig) {
- secp256k1_scalar r, s;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(output != NULL);
- ARG_CHECK(outputlen != NULL);
- ARG_CHECK(sig != NULL);
-
- secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
- return secp256k1_ecdsa_sig_serialize(output, outputlen, &r, &s);
-}
-
-int secp256k1_ecdsa_signature_serialize_compact(const secp256k1_context* ctx, unsigned char *output64, const secp256k1_ecdsa_signature* sig) {
- secp256k1_scalar r, s;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(output64 != NULL);
- ARG_CHECK(sig != NULL);
-
- secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
- secp256k1_scalar_get_b32(&output64[0], &r);
- secp256k1_scalar_get_b32(&output64[32], &s);
- return 1;
-}
-
-int secp256k1_ecdsa_signature_normalize(const secp256k1_context* ctx, secp256k1_ecdsa_signature *sigout, const secp256k1_ecdsa_signature *sigin) {
- secp256k1_scalar r, s;
- int ret = 0;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(sigin != NULL);
-
- secp256k1_ecdsa_signature_load(ctx, &r, &s, sigin);
- ret = secp256k1_scalar_is_high(&s);
- if (sigout != NULL) {
- if (ret) {
- secp256k1_scalar_negate(&s, &s);
- }
- secp256k1_ecdsa_signature_save(sigout, &r, &s);
- }
-
- return ret;
-}
-
-int secp256k1_ecdsa_verify(const secp256k1_context* ctx, const secp256k1_ecdsa_signature *sig, const unsigned char *msg32, const secp256k1_pubkey *pubkey) {
- secp256k1_ge q;
- secp256k1_scalar r, s;
- secp256k1_scalar m;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
- ARG_CHECK(msg32 != NULL);
- ARG_CHECK(sig != NULL);
- ARG_CHECK(pubkey != NULL);
-
- secp256k1_scalar_set_b32(&m, msg32, NULL);
- secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
- return (!secp256k1_scalar_is_high(&s) &&
- secp256k1_pubkey_load(ctx, &q, pubkey) &&
- secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &r, &s, &q, &m));
-}
-
-static int nonce_function_rfc6979(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
- unsigned char keydata[112];
- int keylen = 64;
- secp256k1_rfc6979_hmac_sha256_t rng;
- unsigned int i;
- /* We feed a byte array to the PRNG as input, consisting of:
- * - the private key (32 bytes) and message (32 bytes), see RFC 6979 3.2d.
- * - optionally 32 extra bytes of data, see RFC 6979 3.6 Additional Data.
- * - optionally 16 extra bytes with the algorithm name.
- * Because the arguments have distinct fixed lengths it is not possible for
- * different argument mixtures to emulate each other and result in the same
- * nonces.
- */
- memcpy(keydata, key32, 32);
- memcpy(keydata + 32, msg32, 32);
- if (data != NULL) {
- memcpy(keydata + 64, data, 32);
- keylen = 96;
- }
- if (algo16 != NULL) {
- memcpy(keydata + keylen, algo16, 16);
- keylen += 16;
- }
- secp256k1_rfc6979_hmac_sha256_initialize(&rng, keydata, keylen);
- memset(keydata, 0, sizeof(keydata));
- for (i = 0; i <= counter; i++) {
- secp256k1_rfc6979_hmac_sha256_generate(&rng, nonce32, 32);
- }
- secp256k1_rfc6979_hmac_sha256_finalize(&rng);
- return 1;
-}
-
-const secp256k1_nonce_function secp256k1_nonce_function_rfc6979 = nonce_function_rfc6979;
-const secp256k1_nonce_function secp256k1_nonce_function_default = nonce_function_rfc6979;
-
-int secp256k1_ecdsa_sign(const secp256k1_context* ctx, secp256k1_ecdsa_signature *signature, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void* noncedata) {
- secp256k1_scalar r, s;
- secp256k1_scalar sec, non, msg;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
- ARG_CHECK(msg32 != NULL);
- ARG_CHECK(signature != NULL);
- ARG_CHECK(seckey != NULL);
- if (noncefp == NULL) {
- noncefp = secp256k1_nonce_function_default;
- }
-
- secp256k1_scalar_set_b32(&sec, seckey, &overflow);
- /* Fail if the secret key is invalid. */
- if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
- unsigned char nonce32[32];
- unsigned int count = 0;
- secp256k1_scalar_set_b32(&msg, msg32, NULL);
- while (1) {
- ret = noncefp(nonce32, msg32, seckey, NULL, (void*)noncedata, count);
- if (!ret) {
- break;
- }
- secp256k1_scalar_set_b32(&non, nonce32, &overflow);
- if (!overflow && !secp256k1_scalar_is_zero(&non)) {
- if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &r, &s, &sec, &msg, &non, NULL)) {
- break;
- }
- }
- count++;
- }
- memset(nonce32, 0, 32);
- secp256k1_scalar_clear(&msg);
- secp256k1_scalar_clear(&non);
- secp256k1_scalar_clear(&sec);
- }
- if (ret) {
- secp256k1_ecdsa_signature_save(signature, &r, &s);
- } else {
- memset(signature, 0, sizeof(*signature));
- }
- return ret;
-}
-
-int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsigned char *seckey) {
- secp256k1_scalar sec;
- int ret;
- int overflow;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(seckey != NULL);
-
- secp256k1_scalar_set_b32(&sec, seckey, &overflow);
- ret = !overflow && !secp256k1_scalar_is_zero(&sec);
- secp256k1_scalar_clear(&sec);
- return ret;
-}
-
-int secp256k1_ec_pubkey_create(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *seckey) {
- secp256k1_gej pj;
- secp256k1_ge p;
- secp256k1_scalar sec;
- int overflow;
- int ret = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(pubkey != NULL);
- memset(pubkey, 0, sizeof(*pubkey));
- ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
- ARG_CHECK(seckey != NULL);
-
- secp256k1_scalar_set_b32(&sec, seckey, &overflow);
- ret = (!overflow) & (!secp256k1_scalar_is_zero(&sec));
- if (ret) {
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pj, &sec);
- secp256k1_ge_set_gej(&p, &pj);
- secp256k1_pubkey_save(pubkey, &p);
- }
- secp256k1_scalar_clear(&sec);
- return ret;
-}
-
-int secp256k1_ec_privkey_tweak_add(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {
- secp256k1_scalar term;
- secp256k1_scalar sec;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(seckey != NULL);
- ARG_CHECK(tweak != NULL);
-
- secp256k1_scalar_set_b32(&term, tweak, &overflow);
- secp256k1_scalar_set_b32(&sec, seckey, NULL);
-
- ret = !overflow && secp256k1_eckey_privkey_tweak_add(&sec, &term);
- memset(seckey, 0, 32);
- if (ret) {
- secp256k1_scalar_get_b32(seckey, &sec);
- }
-
- secp256k1_scalar_clear(&sec);
- secp256k1_scalar_clear(&term);
- return ret;
-}
-
-int secp256k1_ec_pubkey_tweak_add(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak) {
- secp256k1_ge p;
- secp256k1_scalar term;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
- ARG_CHECK(pubkey != NULL);
- ARG_CHECK(tweak != NULL);
-
- secp256k1_scalar_set_b32(&term, tweak, &overflow);
- ret = !overflow && secp256k1_pubkey_load(ctx, &p, pubkey);
- memset(pubkey, 0, sizeof(*pubkey));
- if (ret) {
- if (secp256k1_eckey_pubkey_tweak_add(&ctx->ecmult_ctx, &p, &term)) {
- secp256k1_pubkey_save(pubkey, &p);
- } else {
- ret = 0;
- }
- }
-
- return ret;
-}
-
-int secp256k1_ec_privkey_tweak_mul(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {
- secp256k1_scalar factor;
- secp256k1_scalar sec;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(seckey != NULL);
- ARG_CHECK(tweak != NULL);
-
- secp256k1_scalar_set_b32(&factor, tweak, &overflow);
- secp256k1_scalar_set_b32(&sec, seckey, NULL);
- ret = !overflow && secp256k1_eckey_privkey_tweak_mul(&sec, &factor);
- memset(seckey, 0, 32);
- if (ret) {
- secp256k1_scalar_get_b32(seckey, &sec);
- }
-
- secp256k1_scalar_clear(&sec);
- secp256k1_scalar_clear(&factor);
- return ret;
-}
-
-int secp256k1_ec_pubkey_tweak_mul(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak) {
- secp256k1_ge p;
- secp256k1_scalar factor;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
- ARG_CHECK(pubkey != NULL);
- ARG_CHECK(tweak != NULL);
-
- secp256k1_scalar_set_b32(&factor, tweak, &overflow);
- ret = !overflow && secp256k1_pubkey_load(ctx, &p, pubkey);
- memset(pubkey, 0, sizeof(*pubkey));
- if (ret) {
- if (secp256k1_eckey_pubkey_tweak_mul(&ctx->ecmult_ctx, &p, &factor)) {
- secp256k1_pubkey_save(pubkey, &p);
- } else {
- ret = 0;
- }
- }
-
- return ret;
-}
-
-int secp256k1_context_randomize(secp256k1_context* ctx, const unsigned char *seed32) {
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
- secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, seed32);
- return 1;
-}
-
-int secp256k1_ec_pubkey_combine(const secp256k1_context* ctx, secp256k1_pubkey *pubnonce, const secp256k1_pubkey * const *pubnonces, size_t n) {
- size_t i;
- secp256k1_gej Qj;
- secp256k1_ge Q;
-
- ARG_CHECK(pubnonce != NULL);
- memset(pubnonce, 0, sizeof(*pubnonce));
- ARG_CHECK(n >= 1);
- ARG_CHECK(pubnonces != NULL);
-
- secp256k1_gej_set_infinity(&Qj);
-
- for (i = 0; i < n; i++) {
- secp256k1_pubkey_load(ctx, &Q, pubnonces[i]);
- secp256k1_gej_add_ge(&Qj, &Qj, &Q);
- }
- if (secp256k1_gej_is_infinity(&Qj)) {
- return 0;
- }
- secp256k1_ge_set_gej(&Q, &Qj);
- secp256k1_pubkey_save(pubnonce, &Q);
- return 1;
-}
-
-#ifdef ENABLE_MODULE_ECDH
-# include "modules/ecdh/main_impl.h"
-#endif
-
-#ifdef ENABLE_MODULE_SCHNORR
-# include "modules/schnorr/main_impl.h"
-#endif
-
-#ifdef ENABLE_MODULE_RECOVERY
-# include "modules/recovery/main_impl.h"
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/testrand.h op-geth/crypto/secp256k1/libsecp256k1/src/testrand.h
deleted file mode 100644
index f8efa93c7c3f3194a16db581927f69fe2d645d40..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/testrand.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_TESTRAND_H_
-#define _SECP256K1_TESTRAND_H_
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-/* A non-cryptographic RNG used only for test infrastructure. */
-
-/** Seed the pseudorandom number generator for testing. */
-SECP256K1_INLINE static void secp256k1_rand_seed(const unsigned char *seed16);
-
-/** Generate a pseudorandom number in the range [0..2**32-1]. */
-static uint32_t secp256k1_rand32(void);
-
-/** Generate a pseudorandom number in the range [0..2**bits-1]. Bits must be 1 or
- * more. */
-static uint32_t secp256k1_rand_bits(int bits);
-
-/** Generate a pseudorandom number in the range [0..range-1]. */
-static uint32_t secp256k1_rand_int(uint32_t range);
-
-/** Generate a pseudorandom 32-byte array. */
-static void secp256k1_rand256(unsigned char *b32);
-
-/** Generate a pseudorandom 32-byte array with long sequences of zero and one bits. */
-static void secp256k1_rand256_test(unsigned char *b32);
-
-/** Generate pseudorandom bytes with long sequences of zero and one bits. */
-static void secp256k1_rand_bytes_test(unsigned char *bytes, size_t len);
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/testrand_impl.h op-geth/crypto/secp256k1/libsecp256k1/src/testrand_impl.h
deleted file mode 100644
index 15c7b9f12df05216c762af9c4056f3477516bc43..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/testrand_impl.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013-2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_TESTRAND_IMPL_H_
-#define _SECP256K1_TESTRAND_IMPL_H_
-
-#include <stdint.h>
-#include <string.h>
-
-#include "testrand.h"
-#include "hash.h"
-
-static secp256k1_rfc6979_hmac_sha256_t secp256k1_test_rng;
-static uint32_t secp256k1_test_rng_precomputed[8];
-static int secp256k1_test_rng_precomputed_used = 8;
-static uint64_t secp256k1_test_rng_integer;
-static int secp256k1_test_rng_integer_bits_left = 0;
-
-SECP256K1_INLINE static void secp256k1_rand_seed(const unsigned char *seed16) {
- secp256k1_rfc6979_hmac_sha256_initialize(&secp256k1_test_rng, seed16, 16);
-}
-
-SECP256K1_INLINE static uint32_t secp256k1_rand32(void) {
- if (secp256k1_test_rng_precomputed_used == 8) {
- secp256k1_rfc6979_hmac_sha256_generate(&secp256k1_test_rng, (unsigned char*)(&secp256k1_test_rng_precomputed[0]), sizeof(secp256k1_test_rng_precomputed));
- secp256k1_test_rng_precomputed_used = 0;
- }
- return secp256k1_test_rng_precomputed[secp256k1_test_rng_precomputed_used++];
-}
-
-static uint32_t secp256k1_rand_bits(int bits) {
- uint32_t ret;
- if (secp256k1_test_rng_integer_bits_left < bits) {
- secp256k1_test_rng_integer |= (((uint64_t)secp256k1_rand32()) << secp256k1_test_rng_integer_bits_left);
- secp256k1_test_rng_integer_bits_left += 32;
- }
- ret = secp256k1_test_rng_integer;
- secp256k1_test_rng_integer >>= bits;
- secp256k1_test_rng_integer_bits_left -= bits;
- ret &= ((~((uint32_t)0)) >> (32 - bits));
- return ret;
-}
-
-static uint32_t secp256k1_rand_int(uint32_t range) {
- /* We want a uniform integer between 0 and range-1, inclusive.
- * B is the smallest number such that range <= 2**B.
- * two mechanisms implemented here:
- * - generate B bits numbers until one below range is found, and return it
- * - find the largest multiple M of range that is <= 2**(B+A), generate B+A
- * bits numbers until one below M is found, and return it modulo range
- * The second mechanism consumes A more bits of entropy in every iteration,
- * but may need fewer iterations due to M being closer to 2**(B+A) then
- * range is to 2**B. The array below (indexed by B) contains a 0 when the
- * first mechanism is to be used, and the number A otherwise.
- */
- static const int addbits[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0};
- uint32_t trange, mult;
- int bits = 0;
- if (range <= 1) {
- return 0;
- }
- trange = range - 1;
- while (trange > 0) {
- trange >>= 1;
- bits++;
- }
- if (addbits[bits]) {
- bits = bits + addbits[bits];
- mult = ((~((uint32_t)0)) >> (32 - bits)) / range;
- trange = range * mult;
- } else {
- trange = range;
- mult = 1;
- }
- while(1) {
- uint32_t x = secp256k1_rand_bits(bits);
- if (x < trange) {
- return (mult == 1) ? x : (x % range);
- }
- }
-}
-
-static void secp256k1_rand256(unsigned char *b32) {
- secp256k1_rfc6979_hmac_sha256_generate(&secp256k1_test_rng, b32, 32);
-}
-
-static void secp256k1_rand_bytes_test(unsigned char *bytes, size_t len) {
- size_t bits = 0;
- memset(bytes, 0, len);
- while (bits < len * 8) {
- int now;
- uint32_t val;
- now = 1 + (secp256k1_rand_bits(6) * secp256k1_rand_bits(5) + 16) / 31;
- val = secp256k1_rand_bits(1);
- while (now > 0 && bits < len * 8) {
- bytes[bits / 8] |= val << (bits % 8);
- now--;
- bits++;
- }
- }
-}
-
-static void secp256k1_rand256_test(unsigned char *b32) {
- secp256k1_rand_bytes_test(b32, 32);
-}
-
-#endif
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/tests.c op-geth/crypto/secp256k1/libsecp256k1/src/tests.c
deleted file mode 100644
index 9ae7d3028130637ba1159c4c9772cf94267e3711..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/tests.c
+++ /dev/null
@@ -1,4525 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014, 2015 Pieter Wuille, Gregory Maxwell *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <time.h>
-
-#include "secp256k1.c"
-#include "include/secp256k1.h"
-#include "testrand_impl.h"
-
-#ifdef ENABLE_OPENSSL_TESTS
-#include "openssl/bn.h"
-#include "openssl/ec.h"
-#include "openssl/ecdsa.h"
-#include "openssl/obj_mac.h"
-#endif
-
-#include "contrib/lax_der_parsing.c"
-#include "contrib/lax_der_privatekey_parsing.c"
-
-#if !defined(VG_CHECK)
-# if defined(VALGRIND)
-# include <valgrind/memcheck.h>
-# define VG_UNDEF(x,y) VALGRIND_MAKE_MEM_UNDEFINED((x),(y))
-# define VG_CHECK(x,y) VALGRIND_CHECK_MEM_IS_DEFINED((x),(y))
-# else
-# define VG_UNDEF(x,y)
-# define VG_CHECK(x,y)
-# endif
-#endif
-
-static int count = 64;
-static secp256k1_context *ctx = NULL;
-
-static void counting_illegal_callback_fn(const char* str, void* data) {
- /* Dummy callback function that just counts. */
- int32_t *p;
- (void)str;
- p = data;
- (*p)++;
-}
-
-static void uncounting_illegal_callback_fn(const char* str, void* data) {
- /* Dummy callback function that just counts (backwards). */
- int32_t *p;
- (void)str;
- p = data;
- (*p)--;
-}
-
-void random_field_element_test(secp256k1_fe *fe) {
- do {
- unsigned char b32[32];
- secp256k1_rand256_test(b32);
- if (secp256k1_fe_set_b32(fe, b32)) {
- break;
- }
- } while(1);
-}
-
-void random_field_element_magnitude(secp256k1_fe *fe) {
- secp256k1_fe zero;
- int n = secp256k1_rand_int(9);
- secp256k1_fe_normalize(fe);
- if (n == 0) {
- return;
- }
- secp256k1_fe_clear(&zero);
- secp256k1_fe_negate(&zero, &zero, 0);
- secp256k1_fe_mul_int(&zero, n - 1);
- secp256k1_fe_add(fe, &zero);
- VERIFY_CHECK(fe->magnitude == n);
-}
-
-void random_group_element_test(secp256k1_ge *ge) {
- secp256k1_fe fe;
- do {
- random_field_element_test(&fe);
- if (secp256k1_ge_set_xo_var(ge, &fe, secp256k1_rand_bits(1))) {
- secp256k1_fe_normalize(&ge->y);
- break;
- }
- } while(1);
-}
-
-void random_group_element_jacobian_test(secp256k1_gej *gej, const secp256k1_ge *ge) {
- secp256k1_fe z2, z3;
- do {
- random_field_element_test(&gej->z);
- if (!secp256k1_fe_is_zero(&gej->z)) {
- break;
- }
- } while(1);
- secp256k1_fe_sqr(&z2, &gej->z);
- secp256k1_fe_mul(&z3, &z2, &gej->z);
- secp256k1_fe_mul(&gej->x, &ge->x, &z2);
- secp256k1_fe_mul(&gej->y, &ge->y, &z3);
- gej->infinity = ge->infinity;
-}
-
-void random_scalar_order_test(secp256k1_scalar *num) {
- do {
- unsigned char b32[32];
- int overflow = 0;
- secp256k1_rand256_test(b32);
- secp256k1_scalar_set_b32(num, b32, &overflow);
- if (overflow || secp256k1_scalar_is_zero(num)) {
- continue;
- }
- break;
- } while(1);
-}
-
-void random_scalar_order(secp256k1_scalar *num) {
- do {
- unsigned char b32[32];
- int overflow = 0;
- secp256k1_rand256(b32);
- secp256k1_scalar_set_b32(num, b32, &overflow);
- if (overflow || secp256k1_scalar_is_zero(num)) {
- continue;
- }
- break;
- } while(1);
-}
-
-void run_context_tests(void) {
- secp256k1_pubkey pubkey;
- secp256k1_ecdsa_signature sig;
- unsigned char ctmp[32];
- int32_t ecount;
- int32_t ecount2;
- secp256k1_context *none = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
- secp256k1_context *sign = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
- secp256k1_context *vrfy = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);
- secp256k1_context *both = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
-
- secp256k1_gej pubj;
- secp256k1_ge pub;
- secp256k1_scalar msg, key, nonce;
- secp256k1_scalar sigr, sigs;
-
- ecount = 0;
- ecount2 = 10;
- secp256k1_context_set_illegal_callback(vrfy, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(sign, counting_illegal_callback_fn, &ecount2);
- secp256k1_context_set_error_callback(sign, counting_illegal_callback_fn, NULL);
- CHECK(vrfy->error_callback.fn != sign->error_callback.fn);
-
- /*** clone and destroy all of them to make sure cloning was complete ***/
- {
- secp256k1_context *ctx_tmp;
-
- ctx_tmp = none; none = secp256k1_context_clone(none); secp256k1_context_destroy(ctx_tmp);
- ctx_tmp = sign; sign = secp256k1_context_clone(sign); secp256k1_context_destroy(ctx_tmp);
- ctx_tmp = vrfy; vrfy = secp256k1_context_clone(vrfy); secp256k1_context_destroy(ctx_tmp);
- ctx_tmp = both; both = secp256k1_context_clone(both); secp256k1_context_destroy(ctx_tmp);
- }
-
- /* Verify that the error callback makes it across the clone. */
- CHECK(vrfy->error_callback.fn != sign->error_callback.fn);
- /* And that it resets back to default. */
- secp256k1_context_set_error_callback(sign, NULL, NULL);
- CHECK(vrfy->error_callback.fn == sign->error_callback.fn);
-
- /*** attempt to use them ***/
- random_scalar_order_test(&msg);
- random_scalar_order_test(&key);
- secp256k1_ecmult_gen(&both->ecmult_gen_ctx, &pubj, &key);
- secp256k1_ge_set_gej(&pub, &pubj);
-
- /* Verify context-type checking illegal-argument errors. */
- memset(ctmp, 1, 32);
- CHECK(secp256k1_ec_pubkey_create(vrfy, &pubkey, ctmp) == 0);
- CHECK(ecount == 1);
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(sign, &pubkey, ctmp) == 1);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ecdsa_sign(vrfy, &sig, ctmp, ctmp, NULL, NULL) == 0);
- CHECK(ecount == 2);
- VG_UNDEF(&sig, sizeof(sig));
- CHECK(secp256k1_ecdsa_sign(sign, &sig, ctmp, ctmp, NULL, NULL) == 1);
- VG_CHECK(&sig, sizeof(sig));
- CHECK(ecount2 == 10);
- CHECK(secp256k1_ecdsa_verify(sign, &sig, ctmp, &pubkey) == 0);
- CHECK(ecount2 == 11);
- CHECK(secp256k1_ecdsa_verify(vrfy, &sig, ctmp, &pubkey) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_ec_pubkey_tweak_add(sign, &pubkey, ctmp) == 0);
- CHECK(ecount2 == 12);
- CHECK(secp256k1_ec_pubkey_tweak_add(vrfy, &pubkey, ctmp) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_ec_pubkey_tweak_mul(sign, &pubkey, ctmp) == 0);
- CHECK(ecount2 == 13);
- CHECK(secp256k1_ec_pubkey_tweak_mul(vrfy, &pubkey, ctmp) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_context_randomize(vrfy, ctmp) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_context_randomize(sign, NULL) == 1);
- CHECK(ecount2 == 13);
- secp256k1_context_set_illegal_callback(vrfy, NULL, NULL);
- secp256k1_context_set_illegal_callback(sign, NULL, NULL);
-
- /* This shouldn't leak memory, due to already-set tests. */
- secp256k1_ecmult_gen_context_build(&sign->ecmult_gen_ctx, NULL);
- secp256k1_ecmult_context_build(&vrfy->ecmult_ctx, NULL);
-
- /* obtain a working nonce */
- do {
- random_scalar_order_test(&nonce);
- } while(!secp256k1_ecdsa_sig_sign(&both->ecmult_gen_ctx, &sigr, &sigs, &key, &msg, &nonce, NULL));
-
- /* try signing */
- CHECK(secp256k1_ecdsa_sig_sign(&sign->ecmult_gen_ctx, &sigr, &sigs, &key, &msg, &nonce, NULL));
- CHECK(secp256k1_ecdsa_sig_sign(&both->ecmult_gen_ctx, &sigr, &sigs, &key, &msg, &nonce, NULL));
-
- /* try verifying */
- CHECK(secp256k1_ecdsa_sig_verify(&vrfy->ecmult_ctx, &sigr, &sigs, &pub, &msg));
- CHECK(secp256k1_ecdsa_sig_verify(&both->ecmult_ctx, &sigr, &sigs, &pub, &msg));
-
- /* cleanup */
- secp256k1_context_destroy(none);
- secp256k1_context_destroy(sign);
- secp256k1_context_destroy(vrfy);
- secp256k1_context_destroy(both);
- /* Defined as no-op. */
- secp256k1_context_destroy(NULL);
-}
-
-/***** HASH TESTS *****/
-
-void run_sha256_tests(void) {
- static const char *inputs[8] = {
- "", "abc", "message digest", "secure hash algorithm", "SHA256 is considered to be safe",
- "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
- "For this sample, this 63-byte string will be used as input data",
- "This is exactly 64 bytes long, not counting the terminating byte"
- };
- static const unsigned char outputs[8][32] = {
- {0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55},
- {0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad},
- {0xf7, 0x84, 0x6f, 0x55, 0xcf, 0x23, 0xe1, 0x4e, 0xeb, 0xea, 0xb5, 0xb4, 0xe1, 0x55, 0x0c, 0xad, 0x5b, 0x50, 0x9e, 0x33, 0x48, 0xfb, 0xc4, 0xef, 0xa3, 0xa1, 0x41, 0x3d, 0x39, 0x3c, 0xb6, 0x50},
- {0xf3, 0x0c, 0xeb, 0x2b, 0xb2, 0x82, 0x9e, 0x79, 0xe4, 0xca, 0x97, 0x53, 0xd3, 0x5a, 0x8e, 0xcc, 0x00, 0x26, 0x2d, 0x16, 0x4c, 0xc0, 0x77, 0x08, 0x02, 0x95, 0x38, 0x1c, 0xbd, 0x64, 0x3f, 0x0d},
- {0x68, 0x19, 0xd9, 0x15, 0xc7, 0x3f, 0x4d, 0x1e, 0x77, 0xe4, 0xe1, 0xb5, 0x2d, 0x1f, 0xa0, 0xf9, 0xcf, 0x9b, 0xea, 0xea, 0xd3, 0x93, 0x9f, 0x15, 0x87, 0x4b, 0xd9, 0x88, 0xe2, 0xa2, 0x36, 0x30},
- {0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39, 0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67, 0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1},
- {0xf0, 0x8a, 0x78, 0xcb, 0xba, 0xee, 0x08, 0x2b, 0x05, 0x2a, 0xe0, 0x70, 0x8f, 0x32, 0xfa, 0x1e, 0x50, 0xc5, 0xc4, 0x21, 0xaa, 0x77, 0x2b, 0xa5, 0xdb, 0xb4, 0x06, 0xa2, 0xea, 0x6b, 0xe3, 0x42},
- {0xab, 0x64, 0xef, 0xf7, 0xe8, 0x8e, 0x2e, 0x46, 0x16, 0x5e, 0x29, 0xf2, 0xbc, 0xe4, 0x18, 0x26, 0xbd, 0x4c, 0x7b, 0x35, 0x52, 0xf6, 0xb3, 0x82, 0xa9, 0xe7, 0xd3, 0xaf, 0x47, 0xc2, 0x45, 0xf8}
- };
- int i;
- for (i = 0; i < 8; i++) {
- unsigned char out[32];
- secp256k1_sha256_t hasher;
- secp256k1_sha256_initialize(&hasher);
- secp256k1_sha256_write(&hasher, (const unsigned char*)(inputs[i]), strlen(inputs[i]));
- secp256k1_sha256_finalize(&hasher, out);
- CHECK(memcmp(out, outputs[i], 32) == 0);
- if (strlen(inputs[i]) > 0) {
- int split = secp256k1_rand_int(strlen(inputs[i]));
- secp256k1_sha256_initialize(&hasher);
- secp256k1_sha256_write(&hasher, (const unsigned char*)(inputs[i]), split);
- secp256k1_sha256_write(&hasher, (const unsigned char*)(inputs[i] + split), strlen(inputs[i]) - split);
- secp256k1_sha256_finalize(&hasher, out);
- CHECK(memcmp(out, outputs[i], 32) == 0);
- }
- }
-}
-
-void run_hmac_sha256_tests(void) {
- static const char *keys[6] = {
- "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
- "\x4a\x65\x66\x65",
- "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
- "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
- "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
- "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
- };
- static const char *inputs[6] = {
- "\x48\x69\x20\x54\x68\x65\x72\x65",
- "\x77\x68\x61\x74\x20\x64\x6f\x20\x79\x61\x20\x77\x61\x6e\x74\x20\x66\x6f\x72\x20\x6e\x6f\x74\x68\x69\x6e\x67\x3f",
- "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd",
- "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd",
- "\x54\x65\x73\x74\x20\x55\x73\x69\x6e\x67\x20\x4c\x61\x72\x67\x65\x72\x20\x54\x68\x61\x6e\x20\x42\x6c\x6f\x63\x6b\x2d\x53\x69\x7a\x65\x20\x4b\x65\x79\x20\x2d\x20\x48\x61\x73\x68\x20\x4b\x65\x79\x20\x46\x69\x72\x73\x74",
- "\x54\x68\x69\x73\x20\x69\x73\x20\x61\x20\x74\x65\x73\x74\x20\x75\x73\x69\x6e\x67\x20\x61\x20\x6c\x61\x72\x67\x65\x72\x20\x74\x68\x61\x6e\x20\x62\x6c\x6f\x63\x6b\x2d\x73\x69\x7a\x65\x20\x6b\x65\x79\x20\x61\x6e\x64\x20\x61\x20\x6c\x61\x72\x67\x65\x72\x20\x74\x68\x61\x6e\x20\x62\x6c\x6f\x63\x6b\x2d\x73\x69\x7a\x65\x20\x64\x61\x74\x61\x2e\x20\x54\x68\x65\x20\x6b\x65\x79\x20\x6e\x65\x65\x64\x73\x20\x74\x6f\x20\x62\x65\x20\x68\x61\x73\x68\x65\x64\x20\x62\x65\x66\x6f\x72\x65\x20\x62\x65\x69\x6e\x67\x20\x75\x73\x65\x64\x20\x62\x79\x20\x74\x68\x65\x20\x48\x4d\x41\x43\x20\x61\x6c\x67\x6f\x72\x69\x74\x68\x6d\x2e"
- };
- static const unsigned char outputs[6][32] = {
- {0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53, 0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b, 0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7, 0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7},
- {0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e, 0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7, 0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83, 0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43},
- {0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46, 0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7, 0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22, 0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe},
- {0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e, 0xa4, 0xcc, 0x81, 0x98, 0x99, 0xf2, 0x08, 0x3a, 0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07, 0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b},
- {0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f, 0x0d, 0x8a, 0x26, 0xaa, 0xcb, 0xf5, 0xb7, 0x7f, 0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14, 0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54},
- {0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb, 0x27, 0x63, 0x5f, 0xbc, 0xd5, 0xb0, 0xe9, 0x44, 0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93, 0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2}
- };
- int i;
- for (i = 0; i < 6; i++) {
- secp256k1_hmac_sha256_t hasher;
- unsigned char out[32];
- secp256k1_hmac_sha256_initialize(&hasher, (const unsigned char*)(keys[i]), strlen(keys[i]));
- secp256k1_hmac_sha256_write(&hasher, (const unsigned char*)(inputs[i]), strlen(inputs[i]));
- secp256k1_hmac_sha256_finalize(&hasher, out);
- CHECK(memcmp(out, outputs[i], 32) == 0);
- if (strlen(inputs[i]) > 0) {
- int split = secp256k1_rand_int(strlen(inputs[i]));
- secp256k1_hmac_sha256_initialize(&hasher, (const unsigned char*)(keys[i]), strlen(keys[i]));
- secp256k1_hmac_sha256_write(&hasher, (const unsigned char*)(inputs[i]), split);
- secp256k1_hmac_sha256_write(&hasher, (const unsigned char*)(inputs[i] + split), strlen(inputs[i]) - split);
- secp256k1_hmac_sha256_finalize(&hasher, out);
- CHECK(memcmp(out, outputs[i], 32) == 0);
- }
- }
-}
-
-void run_rfc6979_hmac_sha256_tests(void) {
- static const unsigned char key1[65] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x00, 0x4b, 0xf5, 0x12, 0x2f, 0x34, 0x45, 0x54, 0xc5, 0x3b, 0xde, 0x2e, 0xbb, 0x8c, 0xd2, 0xb7, 0xe3, 0xd1, 0x60, 0x0a, 0xd6, 0x31, 0xc3, 0x85, 0xa5, 0xd7, 0xcc, 0xe2, 0x3c, 0x77, 0x85, 0x45, 0x9a, 0};
- static const unsigned char out1[3][32] = {
- {0x4f, 0xe2, 0x95, 0x25, 0xb2, 0x08, 0x68, 0x09, 0x15, 0x9a, 0xcd, 0xf0, 0x50, 0x6e, 0xfb, 0x86, 0xb0, 0xec, 0x93, 0x2c, 0x7b, 0xa4, 0x42, 0x56, 0xab, 0x32, 0x1e, 0x42, 0x1e, 0x67, 0xe9, 0xfb},
- {0x2b, 0xf0, 0xff, 0xf1, 0xd3, 0xc3, 0x78, 0xa2, 0x2d, 0xc5, 0xde, 0x1d, 0x85, 0x65, 0x22, 0x32, 0x5c, 0x65, 0xb5, 0x04, 0x49, 0x1a, 0x0c, 0xbd, 0x01, 0xcb, 0x8f, 0x3a, 0xa6, 0x7f, 0xfd, 0x4a},
- {0xf5, 0x28, 0xb4, 0x10, 0xcb, 0x54, 0x1f, 0x77, 0x00, 0x0d, 0x7a, 0xfb, 0x6c, 0x5b, 0x53, 0xc5, 0xc4, 0x71, 0xea, 0xb4, 0x3e, 0x46, 0x6d, 0x9a, 0xc5, 0x19, 0x0c, 0x39, 0xc8, 0x2f, 0xd8, 0x2e}
- };
-
- static const unsigned char key2[64] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55};
- static const unsigned char out2[3][32] = {
- {0x9c, 0x23, 0x6c, 0x16, 0x5b, 0x82, 0xae, 0x0c, 0xd5, 0x90, 0x65, 0x9e, 0x10, 0x0b, 0x6b, 0xab, 0x30, 0x36, 0xe7, 0xba, 0x8b, 0x06, 0x74, 0x9b, 0xaf, 0x69, 0x81, 0xe1, 0x6f, 0x1a, 0x2b, 0x95},
- {0xdf, 0x47, 0x10, 0x61, 0x62, 0x5b, 0xc0, 0xea, 0x14, 0xb6, 0x82, 0xfe, 0xee, 0x2c, 0x9c, 0x02, 0xf2, 0x35, 0xda, 0x04, 0x20, 0x4c, 0x1d, 0x62, 0xa1, 0x53, 0x6c, 0x6e, 0x17, 0xae, 0xd7, 0xa9},
- {0x75, 0x97, 0x88, 0x7c, 0xbd, 0x76, 0x32, 0x1f, 0x32, 0xe3, 0x04, 0x40, 0x67, 0x9a, 0x22, 0xcf, 0x7f, 0x8d, 0x9d, 0x2e, 0xac, 0x39, 0x0e, 0x58, 0x1f, 0xea, 0x09, 0x1c, 0xe2, 0x02, 0xba, 0x94}
- };
-
- secp256k1_rfc6979_hmac_sha256_t rng;
- unsigned char out[32];
- int i;
-
- secp256k1_rfc6979_hmac_sha256_initialize(&rng, key1, 64);
- for (i = 0; i < 3; i++) {
- secp256k1_rfc6979_hmac_sha256_generate(&rng, out, 32);
- CHECK(memcmp(out, out1[i], 32) == 0);
- }
- secp256k1_rfc6979_hmac_sha256_finalize(&rng);
-
- secp256k1_rfc6979_hmac_sha256_initialize(&rng, key1, 65);
- for (i = 0; i < 3; i++) {
- secp256k1_rfc6979_hmac_sha256_generate(&rng, out, 32);
- CHECK(memcmp(out, out1[i], 32) != 0);
- }
- secp256k1_rfc6979_hmac_sha256_finalize(&rng);
-
- secp256k1_rfc6979_hmac_sha256_initialize(&rng, key2, 64);
- for (i = 0; i < 3; i++) {
- secp256k1_rfc6979_hmac_sha256_generate(&rng, out, 32);
- CHECK(memcmp(out, out2[i], 32) == 0);
- }
- secp256k1_rfc6979_hmac_sha256_finalize(&rng);
-}
-
-/***** RANDOM TESTS *****/
-
-void test_rand_bits(int rand32, int bits) {
- /* (1-1/2^B)^rounds[B] < 1/10^9, so rounds is the number of iterations to
- * get a false negative chance below once in a billion */
- static const unsigned int rounds[7] = {1, 30, 73, 156, 322, 653, 1316};
- /* We try multiplying the results with various odd numbers, which shouldn't
- * influence the uniform distribution modulo a power of 2. */
- static const uint32_t mults[6] = {1, 3, 21, 289, 0x9999, 0x80402011};
- /* We only select up to 6 bits from the output to analyse */
- unsigned int usebits = bits > 6 ? 6 : bits;
- unsigned int maxshift = bits - usebits;
- /* For each of the maxshift+1 usebits-bit sequences inside a bits-bit
- number, track all observed outcomes, one per bit in a uint64_t. */
- uint64_t x[6][27] = {{0}};
- unsigned int i, shift, m;
- /* Multiply the output of all rand calls with the odd number m, which
- should not change the uniformity of its distribution. */
- for (i = 0; i < rounds[usebits]; i++) {
- uint32_t r = (rand32 ? secp256k1_rand32() : secp256k1_rand_bits(bits));
- CHECK((((uint64_t)r) >> bits) == 0);
- for (m = 0; m < sizeof(mults) / sizeof(mults[0]); m++) {
- uint32_t rm = r * mults[m];
- for (shift = 0; shift <= maxshift; shift++) {
- x[m][shift] |= (((uint64_t)1) << ((rm >> shift) & ((1 << usebits) - 1)));
- }
- }
- }
- for (m = 0; m < sizeof(mults) / sizeof(mults[0]); m++) {
- for (shift = 0; shift <= maxshift; shift++) {
- /* Test that the lower usebits bits of x[shift] are 1 */
- CHECK(((~x[m][shift]) << (64 - (1 << usebits))) == 0);
- }
- }
-}
-
-/* Subrange must be a whole divisor of range, and at most 64 */
-void test_rand_int(uint32_t range, uint32_t subrange) {
- /* (1-1/subrange)^rounds < 1/10^9 */
- int rounds = (subrange * 2073) / 100;
- int i;
- uint64_t x = 0;
- CHECK((range % subrange) == 0);
- for (i = 0; i < rounds; i++) {
- uint32_t r = secp256k1_rand_int(range);
- CHECK(r < range);
- r = r % subrange;
- x |= (((uint64_t)1) << r);
- }
- /* Test that the lower subrange bits of x are 1. */
- CHECK(((~x) << (64 - subrange)) == 0);
-}
-
-void run_rand_bits(void) {
- size_t b;
- test_rand_bits(1, 32);
- for (b = 1; b <= 32; b++) {
- test_rand_bits(0, b);
- }
-}
-
-void run_rand_int(void) {
- static const uint32_t ms[] = {1, 3, 17, 1000, 13771, 999999, 33554432};
- static const uint32_t ss[] = {1, 3, 6, 9, 13, 31, 64};
- unsigned int m, s;
- for (m = 0; m < sizeof(ms) / sizeof(ms[0]); m++) {
- for (s = 0; s < sizeof(ss) / sizeof(ss[0]); s++) {
- test_rand_int(ms[m] * ss[s], ss[s]);
- }
- }
-}
-
-/***** NUM TESTS *****/
-
-#ifndef USE_NUM_NONE
-void random_num_negate(secp256k1_num *num) {
- if (secp256k1_rand_bits(1)) {
- secp256k1_num_negate(num);
- }
-}
-
-void random_num_order_test(secp256k1_num *num) {
- secp256k1_scalar sc;
- random_scalar_order_test(&sc);
- secp256k1_scalar_get_num(num, &sc);
-}
-
-void random_num_order(secp256k1_num *num) {
- secp256k1_scalar sc;
- random_scalar_order(&sc);
- secp256k1_scalar_get_num(num, &sc);
-}
-
-void test_num_negate(void) {
- secp256k1_num n1;
- secp256k1_num n2;
- random_num_order_test(&n1); /* n1 = R */
- random_num_negate(&n1);
- secp256k1_num_copy(&n2, &n1); /* n2 = R */
- secp256k1_num_sub(&n1, &n2, &n1); /* n1 = n2-n1 = 0 */
- CHECK(secp256k1_num_is_zero(&n1));
- secp256k1_num_copy(&n1, &n2); /* n1 = R */
- secp256k1_num_negate(&n1); /* n1 = -R */
- CHECK(!secp256k1_num_is_zero(&n1));
- secp256k1_num_add(&n1, &n2, &n1); /* n1 = n2+n1 = 0 */
- CHECK(secp256k1_num_is_zero(&n1));
- secp256k1_num_copy(&n1, &n2); /* n1 = R */
- secp256k1_num_negate(&n1); /* n1 = -R */
- CHECK(secp256k1_num_is_neg(&n1) != secp256k1_num_is_neg(&n2));
- secp256k1_num_negate(&n1); /* n1 = R */
- CHECK(secp256k1_num_eq(&n1, &n2));
-}
-
-void test_num_add_sub(void) {
- int i;
- secp256k1_scalar s;
- secp256k1_num n1;
- secp256k1_num n2;
- secp256k1_num n1p2, n2p1, n1m2, n2m1;
- random_num_order_test(&n1); /* n1 = R1 */
- if (secp256k1_rand_bits(1)) {
- random_num_negate(&n1);
- }
- random_num_order_test(&n2); /* n2 = R2 */
- if (secp256k1_rand_bits(1)) {
- random_num_negate(&n2);
- }
- secp256k1_num_add(&n1p2, &n1, &n2); /* n1p2 = R1 + R2 */
- secp256k1_num_add(&n2p1, &n2, &n1); /* n2p1 = R2 + R1 */
- secp256k1_num_sub(&n1m2, &n1, &n2); /* n1m2 = R1 - R2 */
- secp256k1_num_sub(&n2m1, &n2, &n1); /* n2m1 = R2 - R1 */
- CHECK(secp256k1_num_eq(&n1p2, &n2p1));
- CHECK(!secp256k1_num_eq(&n1p2, &n1m2));
- secp256k1_num_negate(&n2m1); /* n2m1 = -R2 + R1 */
- CHECK(secp256k1_num_eq(&n2m1, &n1m2));
- CHECK(!secp256k1_num_eq(&n2m1, &n1));
- secp256k1_num_add(&n2m1, &n2m1, &n2); /* n2m1 = -R2 + R1 + R2 = R1 */
- CHECK(secp256k1_num_eq(&n2m1, &n1));
- CHECK(!secp256k1_num_eq(&n2p1, &n1));
- secp256k1_num_sub(&n2p1, &n2p1, &n2); /* n2p1 = R2 + R1 - R2 = R1 */
- CHECK(secp256k1_num_eq(&n2p1, &n1));
-
- /* check is_one */
- secp256k1_scalar_set_int(&s, 1);
- secp256k1_scalar_get_num(&n1, &s);
- CHECK(secp256k1_num_is_one(&n1));
- /* check that 2^n + 1 is never 1 */
- secp256k1_scalar_get_num(&n2, &s);
- for (i = 0; i < 250; ++i) {
- secp256k1_num_add(&n1, &n1, &n1); /* n1 *= 2 */
- secp256k1_num_add(&n1p2, &n1, &n2); /* n1p2 = n1 + 1 */
- CHECK(!secp256k1_num_is_one(&n1p2));
- }
-}
-
-void test_num_mod(void) {
- int i;
- secp256k1_scalar s;
- secp256k1_num order, n;
-
- /* check that 0 mod anything is 0 */
- random_scalar_order_test(&s);
- secp256k1_scalar_get_num(&order, &s);
- secp256k1_scalar_set_int(&s, 0);
- secp256k1_scalar_get_num(&n, &s);
- secp256k1_num_mod(&n, &order);
- CHECK(secp256k1_num_is_zero(&n));
-
- /* check that anything mod 1 is 0 */
- secp256k1_scalar_set_int(&s, 1);
- secp256k1_scalar_get_num(&order, &s);
- secp256k1_scalar_get_num(&n, &s);
- secp256k1_num_mod(&n, &order);
- CHECK(secp256k1_num_is_zero(&n));
-
- /* check that increasing the number past 2^256 does not break this */
- random_scalar_order_test(&s);
- secp256k1_scalar_get_num(&n, &s);
- /* multiply by 2^8, which'll test this case with high probability */
- for (i = 0; i < 8; ++i) {
- secp256k1_num_add(&n, &n, &n);
- }
- secp256k1_num_mod(&n, &order);
- CHECK(secp256k1_num_is_zero(&n));
-}
-
-void test_num_jacobi(void) {
- secp256k1_scalar sqr;
- secp256k1_scalar small;
- secp256k1_scalar five; /* five is not a quadratic residue */
- secp256k1_num order, n;
- int i;
- /* squares mod 5 are 1, 4 */
- const int jacobi5[10] = { 0, 1, -1, -1, 1, 0, 1, -1, -1, 1 };
-
- /* check some small values with 5 as the order */
- secp256k1_scalar_set_int(&five, 5);
- secp256k1_scalar_get_num(&order, &five);
- for (i = 0; i < 10; ++i) {
- secp256k1_scalar_set_int(&small, i);
- secp256k1_scalar_get_num(&n, &small);
- CHECK(secp256k1_num_jacobi(&n, &order) == jacobi5[i]);
- }
-
- /** test large values with 5 as group order */
- secp256k1_scalar_get_num(&order, &five);
- /* we first need a scalar which is not a multiple of 5 */
- do {
- secp256k1_num fiven;
- random_scalar_order_test(&sqr);
- secp256k1_scalar_get_num(&fiven, &five);
- secp256k1_scalar_get_num(&n, &sqr);
- secp256k1_num_mod(&n, &fiven);
- } while (secp256k1_num_is_zero(&n));
- /* next force it to be a residue. 2 is a nonresidue mod 5 so we can
- * just multiply by two, i.e. add the number to itself */
- if (secp256k1_num_jacobi(&n, &order) == -1) {
- secp256k1_num_add(&n, &n, &n);
- }
-
- /* test residue */
- CHECK(secp256k1_num_jacobi(&n, &order) == 1);
- /* test nonresidue */
- secp256k1_num_add(&n, &n, &n);
- CHECK(secp256k1_num_jacobi(&n, &order) == -1);
-
- /** test with secp group order as order */
- secp256k1_scalar_order_get_num(&order);
- random_scalar_order_test(&sqr);
- secp256k1_scalar_sqr(&sqr, &sqr);
- /* test residue */
- secp256k1_scalar_get_num(&n, &sqr);
- CHECK(secp256k1_num_jacobi(&n, &order) == 1);
- /* test nonresidue */
- secp256k1_scalar_mul(&sqr, &sqr, &five);
- secp256k1_scalar_get_num(&n, &sqr);
- CHECK(secp256k1_num_jacobi(&n, &order) == -1);
- /* test multiple of the order*/
- CHECK(secp256k1_num_jacobi(&order, &order) == 0);
-
- /* check one less than the order */
- secp256k1_scalar_set_int(&small, 1);
- secp256k1_scalar_get_num(&n, &small);
- secp256k1_num_sub(&n, &order, &n);
- CHECK(secp256k1_num_jacobi(&n, &order) == 1); /* sage confirms this is 1 */
-}
-
-void run_num_smalltests(void) {
- int i;
- for (i = 0; i < 100*count; i++) {
- test_num_negate();
- test_num_add_sub();
- test_num_mod();
- test_num_jacobi();
- }
-}
-#endif
-
-/***** SCALAR TESTS *****/
-
-void scalar_test(void) {
- secp256k1_scalar s;
- secp256k1_scalar s1;
- secp256k1_scalar s2;
-#ifndef USE_NUM_NONE
- secp256k1_num snum, s1num, s2num;
- secp256k1_num order, half_order;
-#endif
- unsigned char c[32];
-
- /* Set 's' to a random scalar, with value 'snum'. */
- random_scalar_order_test(&s);
-
- /* Set 's1' to a random scalar, with value 's1num'. */
- random_scalar_order_test(&s1);
-
- /* Set 's2' to a random scalar, with value 'snum2', and byte array representation 'c'. */
- random_scalar_order_test(&s2);
- secp256k1_scalar_get_b32(c, &s2);
-
-#ifndef USE_NUM_NONE
- secp256k1_scalar_get_num(&snum, &s);
- secp256k1_scalar_get_num(&s1num, &s1);
- secp256k1_scalar_get_num(&s2num, &s2);
-
- secp256k1_scalar_order_get_num(&order);
- half_order = order;
- secp256k1_num_shift(&half_order, 1);
-#endif
-
- {
- int i;
- /* Test that fetching groups of 4 bits from a scalar and recursing n(i)=16*n(i-1)+p(i) reconstructs it. */
- secp256k1_scalar n;
- secp256k1_scalar_set_int(&n, 0);
- for (i = 0; i < 256; i += 4) {
- secp256k1_scalar t;
- int j;
- secp256k1_scalar_set_int(&t, secp256k1_scalar_get_bits(&s, 256 - 4 - i, 4));
- for (j = 0; j < 4; j++) {
- secp256k1_scalar_add(&n, &n, &n);
- }
- secp256k1_scalar_add(&n, &n, &t);
- }
- CHECK(secp256k1_scalar_eq(&n, &s));
- }
-
- {
- /* Test that fetching groups of randomly-sized bits from a scalar and recursing n(i)=b*n(i-1)+p(i) reconstructs it. */
- secp256k1_scalar n;
- int i = 0;
- secp256k1_scalar_set_int(&n, 0);
- while (i < 256) {
- secp256k1_scalar t;
- int j;
- int now = secp256k1_rand_int(15) + 1;
- if (now + i > 256) {
- now = 256 - i;
- }
- secp256k1_scalar_set_int(&t, secp256k1_scalar_get_bits_var(&s, 256 - now - i, now));
- for (j = 0; j < now; j++) {
- secp256k1_scalar_add(&n, &n, &n);
- }
- secp256k1_scalar_add(&n, &n, &t);
- i += now;
- }
- CHECK(secp256k1_scalar_eq(&n, &s));
- }
-
-#ifndef USE_NUM_NONE
- {
- /* Test that adding the scalars together is equal to adding their numbers together modulo the order. */
- secp256k1_num rnum;
- secp256k1_num r2num;
- secp256k1_scalar r;
- secp256k1_num_add(&rnum, &snum, &s2num);
- secp256k1_num_mod(&rnum, &order);
- secp256k1_scalar_add(&r, &s, &s2);
- secp256k1_scalar_get_num(&r2num, &r);
- CHECK(secp256k1_num_eq(&rnum, &r2num));
- }
-
- {
- /* Test that multiplying the scalars is equal to multiplying their numbers modulo the order. */
- secp256k1_scalar r;
- secp256k1_num r2num;
- secp256k1_num rnum;
- secp256k1_num_mul(&rnum, &snum, &s2num);
- secp256k1_num_mod(&rnum, &order);
- secp256k1_scalar_mul(&r, &s, &s2);
- secp256k1_scalar_get_num(&r2num, &r);
- CHECK(secp256k1_num_eq(&rnum, &r2num));
- /* The result can only be zero if at least one of the factors was zero. */
- CHECK(secp256k1_scalar_is_zero(&r) == (secp256k1_scalar_is_zero(&s) || secp256k1_scalar_is_zero(&s2)));
- /* The results can only be equal to one of the factors if that factor was zero, or the other factor was one. */
- CHECK(secp256k1_num_eq(&rnum, &snum) == (secp256k1_scalar_is_zero(&s) || secp256k1_scalar_is_one(&s2)));
- CHECK(secp256k1_num_eq(&rnum, &s2num) == (secp256k1_scalar_is_zero(&s2) || secp256k1_scalar_is_one(&s)));
- }
-
- {
- secp256k1_scalar neg;
- secp256k1_num negnum;
- secp256k1_num negnum2;
- /* Check that comparison with zero matches comparison with zero on the number. */
- CHECK(secp256k1_num_is_zero(&snum) == secp256k1_scalar_is_zero(&s));
- /* Check that comparison with the half order is equal to testing for high scalar. */
- CHECK(secp256k1_scalar_is_high(&s) == (secp256k1_num_cmp(&snum, &half_order) > 0));
- secp256k1_scalar_negate(&neg, &s);
- secp256k1_num_sub(&negnum, &order, &snum);
- secp256k1_num_mod(&negnum, &order);
- /* Check that comparison with the half order is equal to testing for high scalar after negation. */
- CHECK(secp256k1_scalar_is_high(&neg) == (secp256k1_num_cmp(&negnum, &half_order) > 0));
- /* Negating should change the high property, unless the value was already zero. */
- CHECK((secp256k1_scalar_is_high(&s) == secp256k1_scalar_is_high(&neg)) == secp256k1_scalar_is_zero(&s));
- secp256k1_scalar_get_num(&negnum2, &neg);
- /* Negating a scalar should be equal to (order - n) mod order on the number. */
- CHECK(secp256k1_num_eq(&negnum, &negnum2));
- secp256k1_scalar_add(&neg, &neg, &s);
- /* Adding a number to its negation should result in zero. */
- CHECK(secp256k1_scalar_is_zero(&neg));
- secp256k1_scalar_negate(&neg, &neg);
- /* Negating zero should still result in zero. */
- CHECK(secp256k1_scalar_is_zero(&neg));
- }
-
- {
- /* Test secp256k1_scalar_mul_shift_var. */
- secp256k1_scalar r;
- secp256k1_num one;
- secp256k1_num rnum;
- secp256k1_num rnum2;
- unsigned char cone[1] = {0x01};
- unsigned int shift = 256 + secp256k1_rand_int(257);
- secp256k1_scalar_mul_shift_var(&r, &s1, &s2, shift);
- secp256k1_num_mul(&rnum, &s1num, &s2num);
- secp256k1_num_shift(&rnum, shift - 1);
- secp256k1_num_set_bin(&one, cone, 1);
- secp256k1_num_add(&rnum, &rnum, &one);
- secp256k1_num_shift(&rnum, 1);
- secp256k1_scalar_get_num(&rnum2, &r);
- CHECK(secp256k1_num_eq(&rnum, &rnum2));
- }
-
- {
- /* test secp256k1_scalar_shr_int */
- secp256k1_scalar r;
- int i;
- random_scalar_order_test(&r);
- for (i = 0; i < 100; ++i) {
- int low;
- int shift = 1 + secp256k1_rand_int(15);
- int expected = r.d[0] % (1 << shift);
- low = secp256k1_scalar_shr_int(&r, shift);
- CHECK(expected == low);
- }
- }
-#endif
-
- {
- /* Test that scalar inverses are equal to the inverse of their number modulo the order. */
- if (!secp256k1_scalar_is_zero(&s)) {
- secp256k1_scalar inv;
-#ifndef USE_NUM_NONE
- secp256k1_num invnum;
- secp256k1_num invnum2;
-#endif
- secp256k1_scalar_inverse(&inv, &s);
-#ifndef USE_NUM_NONE
- secp256k1_num_mod_inverse(&invnum, &snum, &order);
- secp256k1_scalar_get_num(&invnum2, &inv);
- CHECK(secp256k1_num_eq(&invnum, &invnum2));
-#endif
- secp256k1_scalar_mul(&inv, &inv, &s);
- /* Multiplying a scalar with its inverse must result in one. */
- CHECK(secp256k1_scalar_is_one(&inv));
- secp256k1_scalar_inverse(&inv, &inv);
- /* Inverting one must result in one. */
- CHECK(secp256k1_scalar_is_one(&inv));
-#ifndef USE_NUM_NONE
- secp256k1_scalar_get_num(&invnum, &inv);
- CHECK(secp256k1_num_is_one(&invnum));
-#endif
- }
- }
-
- {
- /* Test commutativity of add. */
- secp256k1_scalar r1, r2;
- secp256k1_scalar_add(&r1, &s1, &s2);
- secp256k1_scalar_add(&r2, &s2, &s1);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- secp256k1_scalar r1, r2;
- secp256k1_scalar b;
- int i;
- /* Test add_bit. */
- int bit = secp256k1_rand_bits(8);
- secp256k1_scalar_set_int(&b, 1);
- CHECK(secp256k1_scalar_is_one(&b));
- for (i = 0; i < bit; i++) {
- secp256k1_scalar_add(&b, &b, &b);
- }
- r1 = s1;
- r2 = s1;
- if (!secp256k1_scalar_add(&r1, &r1, &b)) {
- /* No overflow happened. */
- secp256k1_scalar_cadd_bit(&r2, bit, 1);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- /* cadd is a noop when flag is zero */
- secp256k1_scalar_cadd_bit(&r2, bit, 0);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
- }
-
- {
- /* Test commutativity of mul. */
- secp256k1_scalar r1, r2;
- secp256k1_scalar_mul(&r1, &s1, &s2);
- secp256k1_scalar_mul(&r2, &s2, &s1);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- /* Test associativity of add. */
- secp256k1_scalar r1, r2;
- secp256k1_scalar_add(&r1, &s1, &s2);
- secp256k1_scalar_add(&r1, &r1, &s);
- secp256k1_scalar_add(&r2, &s2, &s);
- secp256k1_scalar_add(&r2, &s1, &r2);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- /* Test associativity of mul. */
- secp256k1_scalar r1, r2;
- secp256k1_scalar_mul(&r1, &s1, &s2);
- secp256k1_scalar_mul(&r1, &r1, &s);
- secp256k1_scalar_mul(&r2, &s2, &s);
- secp256k1_scalar_mul(&r2, &s1, &r2);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- /* Test distributitivity of mul over add. */
- secp256k1_scalar r1, r2, t;
- secp256k1_scalar_add(&r1, &s1, &s2);
- secp256k1_scalar_mul(&r1, &r1, &s);
- secp256k1_scalar_mul(&r2, &s1, &s);
- secp256k1_scalar_mul(&t, &s2, &s);
- secp256k1_scalar_add(&r2, &r2, &t);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- /* Test square. */
- secp256k1_scalar r1, r2;
- secp256k1_scalar_sqr(&r1, &s1);
- secp256k1_scalar_mul(&r2, &s1, &s1);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- /* Test multiplicative identity. */
- secp256k1_scalar r1, v1;
- secp256k1_scalar_set_int(&v1,1);
- secp256k1_scalar_mul(&r1, &s1, &v1);
- CHECK(secp256k1_scalar_eq(&r1, &s1));
- }
-
- {
- /* Test additive identity. */
- secp256k1_scalar r1, v0;
- secp256k1_scalar_set_int(&v0,0);
- secp256k1_scalar_add(&r1, &s1, &v0);
- CHECK(secp256k1_scalar_eq(&r1, &s1));
- }
-
- {
- /* Test zero product property. */
- secp256k1_scalar r1, v0;
- secp256k1_scalar_set_int(&v0,0);
- secp256k1_scalar_mul(&r1, &s1, &v0);
- CHECK(secp256k1_scalar_eq(&r1, &v0));
- }
-
-}
-
-void run_scalar_tests(void) {
- int i;
- for (i = 0; i < 128 * count; i++) {
- scalar_test();
- }
-
- {
- /* (-1)+1 should be zero. */
- secp256k1_scalar s, o;
- secp256k1_scalar_set_int(&s, 1);
- CHECK(secp256k1_scalar_is_one(&s));
- secp256k1_scalar_negate(&o, &s);
- secp256k1_scalar_add(&o, &o, &s);
- CHECK(secp256k1_scalar_is_zero(&o));
- secp256k1_scalar_negate(&o, &o);
- CHECK(secp256k1_scalar_is_zero(&o));
- }
-
-#ifndef USE_NUM_NONE
- {
- /* A scalar with value of the curve order should be 0. */
- secp256k1_num order;
- secp256k1_scalar zero;
- unsigned char bin[32];
- int overflow = 0;
- secp256k1_scalar_order_get_num(&order);
- secp256k1_num_get_bin(bin, 32, &order);
- secp256k1_scalar_set_b32(&zero, bin, &overflow);
- CHECK(overflow == 1);
- CHECK(secp256k1_scalar_is_zero(&zero));
- }
-#endif
-
- {
- /* Does check_overflow check catch all ones? */
- static const secp256k1_scalar overflowed = SECP256K1_SCALAR_CONST(
- 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL,
- 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL
- );
- CHECK(secp256k1_scalar_check_overflow(&overflowed));
- }
-
- {
- /* Static test vectors.
- * These were reduced from ~10^12 random vectors based on comparison-decision
- * and edge-case coverage on 32-bit and 64-bit implementations.
- * The responses were generated with Sage 5.9.
- */
- secp256k1_scalar x;
- secp256k1_scalar y;
- secp256k1_scalar z;
- secp256k1_scalar zz;
- secp256k1_scalar one;
- secp256k1_scalar r1;
- secp256k1_scalar r2;
-#if defined(USE_SCALAR_INV_NUM)
- secp256k1_scalar zzv;
-#endif
- int overflow;
- unsigned char chal[33][2][32] = {
- {{0xff, 0xff, 0x03, 0x07, 0x00, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff,
- 0xff, 0xff, 0x03, 0x00, 0xc0, 0xff, 0xff, 0xff},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff}},
- {{0xef, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
- {0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0,
- 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x80, 0xff}},
- {{0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0x3f, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x00},
- {0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xe0,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0x1e, 0xf8, 0xff, 0xff, 0xff, 0xfd, 0xff},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f,
- 0x00, 0x00, 0x00, 0xf8, 0xff, 0x03, 0x00, 0xe0,
- 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff,
- 0xf3, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0x1c, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xe0, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00,
- 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x1f, 0x00, 0x00, 0x80, 0xff, 0xff, 0x3f,
- 0x00, 0xfe, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0xff, 0x00, 0x0f, 0xfc, 0x9f,
- 0xff, 0xff, 0xff, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0x0f, 0xfc, 0xff, 0x7f, 0x00, 0x00, 0x00,
- 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00},
- {0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
- 0x00, 0x00, 0xf8, 0xff, 0x0f, 0xc0, 0xff, 0xff,
- 0xff, 0x1f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0x07, 0x80, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff,
- 0xf7, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0x00,
- 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xf0},
- {0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
- {{0x00, 0xf8, 0xff, 0x03, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x03, 0xc0, 0xff, 0x0f, 0xfc, 0xff},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0xff, 0xff,
- 0xff, 0x01, 0x00, 0x00, 0x00, 0x3f, 0x00, 0xc0,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
- {{0x8f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x7f, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x03, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0x00, 0x00, 0x80, 0xff, 0x7f},
- {0xff, 0xcf, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
- 0x00, 0xc0, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff,
- 0xbf, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x80, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff,
- 0xff, 0xff, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0x01, 0xfc, 0xff, 0x01, 0x00, 0xfe, 0xff},
- {0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00}},
- {{0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0x7f, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0xf8, 0xff, 0x01, 0x00, 0xf0, 0xff, 0xff,
- 0xe0, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x00},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
- 0xfc, 0xff, 0xff, 0x3f, 0xf0, 0xff, 0xff, 0x3f,
- 0x00, 0x00, 0xf8, 0x07, 0x00, 0x00, 0x00, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x0f, 0x7e, 0x00, 0x00}},
- {{0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x1f, 0x00, 0x00, 0xfe, 0x07, 0x00},
- {0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xfb, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60}},
- {{0xff, 0x01, 0x00, 0xff, 0xff, 0xff, 0x0f, 0x00,
- 0x80, 0x7f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x03,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
- {0xff, 0xff, 0x1f, 0x00, 0xf0, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00}},
- {{0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03,
- 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xc0, 0xff, 0xff, 0xcf, 0xff, 0x1f, 0x00, 0x00,
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x7e,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x00},
- {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0x7f, 0x00, 0x80, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00},
- {0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x80,
- 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
- 0xff, 0x7f, 0xf8, 0xff, 0xff, 0x1f, 0x00, 0xfe}},
- {{0xff, 0xff, 0xff, 0x3f, 0xf8, 0xff, 0xff, 0xff,
- 0xff, 0x03, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x00,
- 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0x01, 0x80, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x40}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
- {0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xc0,
- 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00,
- 0xf0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff}},
- {{0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x40},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0x7e, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x07, 0x00,
- 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
- 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
- {0xff, 0x01, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff,
- 0xff, 0xff, 0x3f, 0x00, 0xf8, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xf1, 0x7f, 0x00}},
- {{0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x00},
- {0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff,
- 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f,
- 0x00, 0x00, 0xfc, 0xff, 0xff, 0x01, 0xff, 0xff}},
- {{0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0x03, 0xe0, 0x01,
- 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xfc, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00},
- {0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
- 0xfe, 0xff, 0xff, 0xf0, 0x07, 0x00, 0x3c, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x07, 0xe0, 0xff, 0x00, 0x00, 0x00}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf8,
- 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x80, 0x00,
- 0x00, 0x00, 0x00, 0xc0, 0x7f, 0xfe, 0xff, 0x1f,
- 0x00, 0xfe, 0xff, 0x03, 0x00, 0x00, 0xfe, 0xff}},
- {{0xff, 0xff, 0x81, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x83,
- 0xff, 0xff, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xf0},
- {0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00,
- 0xf8, 0x07, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xc7, 0xff, 0xff, 0xe0, 0xff, 0xff, 0xff}},
- {{0x82, 0xc9, 0xfa, 0xb0, 0x68, 0x04, 0xa0, 0x00,
- 0x82, 0xc9, 0xfa, 0xb0, 0x68, 0x04, 0xa0, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x6f, 0x03, 0xfb,
- 0xfa, 0x8a, 0x7d, 0xdf, 0x13, 0x86, 0xe2, 0x03},
- {0x82, 0xc9, 0xfa, 0xb0, 0x68, 0x04, 0xa0, 0x00,
- 0x82, 0xc9, 0xfa, 0xb0, 0x68, 0x04, 0xa0, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x6f, 0x03, 0xfb,
- 0xfa, 0x8a, 0x7d, 0xdf, 0x13, 0x86, 0xe2, 0x03}}
- };
- unsigned char res[33][2][32] = {
- {{0x0c, 0x3b, 0x0a, 0xca, 0x8d, 0x1a, 0x2f, 0xb9,
- 0x8a, 0x7b, 0x53, 0x5a, 0x1f, 0xc5, 0x22, 0xa1,
- 0x07, 0x2a, 0x48, 0xea, 0x02, 0xeb, 0xb3, 0xd6,
- 0x20, 0x1e, 0x86, 0xd0, 0x95, 0xf6, 0x92, 0x35},
- {0xdc, 0x90, 0x7a, 0x07, 0x2e, 0x1e, 0x44, 0x6d,
- 0xf8, 0x15, 0x24, 0x5b, 0x5a, 0x96, 0x37, 0x9c,
- 0x37, 0x7b, 0x0d, 0xac, 0x1b, 0x65, 0x58, 0x49,
- 0x43, 0xb7, 0x31, 0xbb, 0xa7, 0xf4, 0x97, 0x15}},
- {{0xf1, 0xf7, 0x3a, 0x50, 0xe6, 0x10, 0xba, 0x22,
- 0x43, 0x4d, 0x1f, 0x1f, 0x7c, 0x27, 0xca, 0x9c,
- 0xb8, 0xb6, 0xa0, 0xfc, 0xd8, 0xc0, 0x05, 0x2f,
- 0xf7, 0x08, 0xe1, 0x76, 0xdd, 0xd0, 0x80, 0xc8},
- {0xe3, 0x80, 0x80, 0xb8, 0xdb, 0xe3, 0xa9, 0x77,
- 0x00, 0xb0, 0xf5, 0x2e, 0x27, 0xe2, 0x68, 0xc4,
- 0x88, 0xe8, 0x04, 0xc1, 0x12, 0xbf, 0x78, 0x59,
- 0xe6, 0xa9, 0x7c, 0xe1, 0x81, 0xdd, 0xb9, 0xd5}},
- {{0x96, 0xe2, 0xee, 0x01, 0xa6, 0x80, 0x31, 0xef,
- 0x5c, 0xd0, 0x19, 0xb4, 0x7d, 0x5f, 0x79, 0xab,
- 0xa1, 0x97, 0xd3, 0x7e, 0x33, 0xbb, 0x86, 0x55,
- 0x60, 0x20, 0x10, 0x0d, 0x94, 0x2d, 0x11, 0x7c},
- {0xcc, 0xab, 0xe0, 0xe8, 0x98, 0x65, 0x12, 0x96,
- 0x38, 0x5a, 0x1a, 0xf2, 0x85, 0x23, 0x59, 0x5f,
- 0xf9, 0xf3, 0xc2, 0x81, 0x70, 0x92, 0x65, 0x12,
- 0x9c, 0x65, 0x1e, 0x96, 0x00, 0xef, 0xe7, 0x63}},
- {{0xac, 0x1e, 0x62, 0xc2, 0x59, 0xfc, 0x4e, 0x5c,
- 0x83, 0xb0, 0xd0, 0x6f, 0xce, 0x19, 0xf6, 0xbf,
- 0xa4, 0xb0, 0xe0, 0x53, 0x66, 0x1f, 0xbf, 0xc9,
- 0x33, 0x47, 0x37, 0xa9, 0x3d, 0x5d, 0xb0, 0x48},
- {0x86, 0xb9, 0x2a, 0x7f, 0x8e, 0xa8, 0x60, 0x42,
- 0x26, 0x6d, 0x6e, 0x1c, 0xa2, 0xec, 0xe0, 0xe5,
- 0x3e, 0x0a, 0x33, 0xbb, 0x61, 0x4c, 0x9f, 0x3c,
- 0xd1, 0xdf, 0x49, 0x33, 0xcd, 0x72, 0x78, 0x18}},
- {{0xf7, 0xd3, 0xcd, 0x49, 0x5c, 0x13, 0x22, 0xfb,
- 0x2e, 0xb2, 0x2f, 0x27, 0xf5, 0x8a, 0x5d, 0x74,
- 0xc1, 0x58, 0xc5, 0xc2, 0x2d, 0x9f, 0x52, 0xc6,
- 0x63, 0x9f, 0xba, 0x05, 0x76, 0x45, 0x7a, 0x63},
- {0x8a, 0xfa, 0x55, 0x4d, 0xdd, 0xa3, 0xb2, 0xc3,
- 0x44, 0xfd, 0xec, 0x72, 0xde, 0xef, 0xc0, 0x99,
- 0xf5, 0x9f, 0xe2, 0x52, 0xb4, 0x05, 0x32, 0x58,
- 0x57, 0xc1, 0x8f, 0xea, 0xc3, 0x24, 0x5b, 0x94}},
- {{0x05, 0x83, 0xee, 0xdd, 0x64, 0xf0, 0x14, 0x3b,
- 0xa0, 0x14, 0x4a, 0x3a, 0x41, 0x82, 0x7c, 0xa7,
- 0x2c, 0xaa, 0xb1, 0x76, 0xbb, 0x59, 0x64, 0x5f,
- 0x52, 0xad, 0x25, 0x29, 0x9d, 0x8f, 0x0b, 0xb0},
- {0x7e, 0xe3, 0x7c, 0xca, 0xcd, 0x4f, 0xb0, 0x6d,
- 0x7a, 0xb2, 0x3e, 0xa0, 0x08, 0xb9, 0xa8, 0x2d,
- 0xc2, 0xf4, 0x99, 0x66, 0xcc, 0xac, 0xd8, 0xb9,
- 0x72, 0x2a, 0x4a, 0x3e, 0x0f, 0x7b, 0xbf, 0xf4}},
- {{0x8c, 0x9c, 0x78, 0x2b, 0x39, 0x61, 0x7e, 0xf7,
- 0x65, 0x37, 0x66, 0x09, 0x38, 0xb9, 0x6f, 0x70,
- 0x78, 0x87, 0xff, 0xcf, 0x93, 0xca, 0x85, 0x06,
- 0x44, 0x84, 0xa7, 0xfe, 0xd3, 0xa4, 0xe3, 0x7e},
- {0xa2, 0x56, 0x49, 0x23, 0x54, 0xa5, 0x50, 0xe9,
- 0x5f, 0xf0, 0x4d, 0xe7, 0xdc, 0x38, 0x32, 0x79,
- 0x4f, 0x1c, 0xb7, 0xe4, 0xbb, 0xf8, 0xbb, 0x2e,
- 0x40, 0x41, 0x4b, 0xcc, 0xe3, 0x1e, 0x16, 0x36}},
- {{0x0c, 0x1e, 0xd7, 0x09, 0x25, 0x40, 0x97, 0xcb,
- 0x5c, 0x46, 0xa8, 0xda, 0xef, 0x25, 0xd5, 0xe5,
- 0x92, 0x4d, 0xcf, 0xa3, 0xc4, 0x5d, 0x35, 0x4a,
- 0xe4, 0x61, 0x92, 0xf3, 0xbf, 0x0e, 0xcd, 0xbe},
- {0xe4, 0xaf, 0x0a, 0xb3, 0x30, 0x8b, 0x9b, 0x48,
- 0x49, 0x43, 0xc7, 0x64, 0x60, 0x4a, 0x2b, 0x9e,
- 0x95, 0x5f, 0x56, 0xe8, 0x35, 0xdc, 0xeb, 0xdc,
- 0xc7, 0xc4, 0xfe, 0x30, 0x40, 0xc7, 0xbf, 0xa4}},
- {{0xd4, 0xa0, 0xf5, 0x81, 0x49, 0x6b, 0xb6, 0x8b,
- 0x0a, 0x69, 0xf9, 0xfe, 0xa8, 0x32, 0xe5, 0xe0,
- 0xa5, 0xcd, 0x02, 0x53, 0xf9, 0x2c, 0xe3, 0x53,
- 0x83, 0x36, 0xc6, 0x02, 0xb5, 0xeb, 0x64, 0xb8},
- {0x1d, 0x42, 0xb9, 0xf9, 0xe9, 0xe3, 0x93, 0x2c,
- 0x4c, 0xee, 0x6c, 0x5a, 0x47, 0x9e, 0x62, 0x01,
- 0x6b, 0x04, 0xfe, 0xa4, 0x30, 0x2b, 0x0d, 0x4f,
- 0x71, 0x10, 0xd3, 0x55, 0xca, 0xf3, 0x5e, 0x80}},
- {{0x77, 0x05, 0xf6, 0x0c, 0x15, 0x9b, 0x45, 0xe7,
- 0xb9, 0x11, 0xb8, 0xf5, 0xd6, 0xda, 0x73, 0x0c,
- 0xda, 0x92, 0xea, 0xd0, 0x9d, 0xd0, 0x18, 0x92,
- 0xce, 0x9a, 0xaa, 0xee, 0x0f, 0xef, 0xde, 0x30},
- {0xf1, 0xf1, 0xd6, 0x9b, 0x51, 0xd7, 0x77, 0x62,
- 0x52, 0x10, 0xb8, 0x7a, 0x84, 0x9d, 0x15, 0x4e,
- 0x07, 0xdc, 0x1e, 0x75, 0x0d, 0x0c, 0x3b, 0xdb,
- 0x74, 0x58, 0x62, 0x02, 0x90, 0x54, 0x8b, 0x43}},
- {{0xa6, 0xfe, 0x0b, 0x87, 0x80, 0x43, 0x67, 0x25,
- 0x57, 0x5d, 0xec, 0x40, 0x50, 0x08, 0xd5, 0x5d,
- 0x43, 0xd7, 0xe0, 0xaa, 0xe0, 0x13, 0xb6, 0xb0,
- 0xc0, 0xd4, 0xe5, 0x0d, 0x45, 0x83, 0xd6, 0x13},
- {0x40, 0x45, 0x0a, 0x92, 0x31, 0xea, 0x8c, 0x60,
- 0x8c, 0x1f, 0xd8, 0x76, 0x45, 0xb9, 0x29, 0x00,
- 0x26, 0x32, 0xd8, 0xa6, 0x96, 0x88, 0xe2, 0xc4,
- 0x8b, 0xdb, 0x7f, 0x17, 0x87, 0xcc, 0xc8, 0xf2}},
- {{0xc2, 0x56, 0xe2, 0xb6, 0x1a, 0x81, 0xe7, 0x31,
- 0x63, 0x2e, 0xbb, 0x0d, 0x2f, 0x81, 0x67, 0xd4,
- 0x22, 0xe2, 0x38, 0x02, 0x25, 0x97, 0xc7, 0x88,
- 0x6e, 0xdf, 0xbe, 0x2a, 0xa5, 0x73, 0x63, 0xaa},
- {0x50, 0x45, 0xe2, 0xc3, 0xbd, 0x89, 0xfc, 0x57,
- 0xbd, 0x3c, 0xa3, 0x98, 0x7e, 0x7f, 0x36, 0x38,
- 0x92, 0x39, 0x1f, 0x0f, 0x81, 0x1a, 0x06, 0x51,
- 0x1f, 0x8d, 0x6a, 0xff, 0x47, 0x16, 0x06, 0x9c}},
- {{0x33, 0x95, 0xa2, 0x6f, 0x27, 0x5f, 0x9c, 0x9c,
- 0x64, 0x45, 0xcb, 0xd1, 0x3c, 0xee, 0x5e, 0x5f,
- 0x48, 0xa6, 0xaf, 0xe3, 0x79, 0xcf, 0xb1, 0xe2,
- 0xbf, 0x55, 0x0e, 0xa2, 0x3b, 0x62, 0xf0, 0xe4},
- {0x14, 0xe8, 0x06, 0xe3, 0xbe, 0x7e, 0x67, 0x01,
- 0xc5, 0x21, 0x67, 0xd8, 0x54, 0xb5, 0x7f, 0xa4,
- 0xf9, 0x75, 0x70, 0x1c, 0xfd, 0x79, 0xdb, 0x86,
- 0xad, 0x37, 0x85, 0x83, 0x56, 0x4e, 0xf0, 0xbf}},
- {{0xbc, 0xa6, 0xe0, 0x56, 0x4e, 0xef, 0xfa, 0xf5,
- 0x1d, 0x5d, 0x3f, 0x2a, 0x5b, 0x19, 0xab, 0x51,
- 0xc5, 0x8b, 0xdd, 0x98, 0x28, 0x35, 0x2f, 0xc3,
- 0x81, 0x4f, 0x5c, 0xe5, 0x70, 0xb9, 0xeb, 0x62},
- {0xc4, 0x6d, 0x26, 0xb0, 0x17, 0x6b, 0xfe, 0x6c,
- 0x12, 0xf8, 0xe7, 0xc1, 0xf5, 0x2f, 0xfa, 0x91,
- 0x13, 0x27, 0xbd, 0x73, 0xcc, 0x33, 0x31, 0x1c,
- 0x39, 0xe3, 0x27, 0x6a, 0x95, 0xcf, 0xc5, 0xfb}},
- {{0x30, 0xb2, 0x99, 0x84, 0xf0, 0x18, 0x2a, 0x6e,
- 0x1e, 0x27, 0xed, 0xa2, 0x29, 0x99, 0x41, 0x56,
- 0xe8, 0xd4, 0x0d, 0xef, 0x99, 0x9c, 0xf3, 0x58,
- 0x29, 0x55, 0x1a, 0xc0, 0x68, 0xd6, 0x74, 0xa4},
- {0x07, 0x9c, 0xe7, 0xec, 0xf5, 0x36, 0x73, 0x41,
- 0xa3, 0x1c, 0xe5, 0x93, 0x97, 0x6a, 0xfd, 0xf7,
- 0x53, 0x18, 0xab, 0xaf, 0xeb, 0x85, 0xbd, 0x92,
- 0x90, 0xab, 0x3c, 0xbf, 0x30, 0x82, 0xad, 0xf6}},
- {{0xc6, 0x87, 0x8a, 0x2a, 0xea, 0xc0, 0xa9, 0xec,
- 0x6d, 0xd3, 0xdc, 0x32, 0x23, 0xce, 0x62, 0x19,
- 0xa4, 0x7e, 0xa8, 0xdd, 0x1c, 0x33, 0xae, 0xd3,
- 0x4f, 0x62, 0x9f, 0x52, 0xe7, 0x65, 0x46, 0xf4},
- {0x97, 0x51, 0x27, 0x67, 0x2d, 0xa2, 0x82, 0x87,
- 0x98, 0xd3, 0xb6, 0x14, 0x7f, 0x51, 0xd3, 0x9a,
- 0x0b, 0xd0, 0x76, 0x81, 0xb2, 0x4f, 0x58, 0x92,
- 0xa4, 0x86, 0xa1, 0xa7, 0x09, 0x1d, 0xef, 0x9b}},
- {{0xb3, 0x0f, 0x2b, 0x69, 0x0d, 0x06, 0x90, 0x64,
- 0xbd, 0x43, 0x4c, 0x10, 0xe8, 0x98, 0x1c, 0xa3,
- 0xe1, 0x68, 0xe9, 0x79, 0x6c, 0x29, 0x51, 0x3f,
- 0x41, 0xdc, 0xdf, 0x1f, 0xf3, 0x60, 0xbe, 0x33},
- {0xa1, 0x5f, 0xf7, 0x1d, 0xb4, 0x3e, 0x9b, 0x3c,
- 0xe7, 0xbd, 0xb6, 0x06, 0xd5, 0x60, 0x06, 0x6d,
- 0x50, 0xd2, 0xf4, 0x1a, 0x31, 0x08, 0xf2, 0xea,
- 0x8e, 0xef, 0x5f, 0x7d, 0xb6, 0xd0, 0xc0, 0x27}},
- {{0x62, 0x9a, 0xd9, 0xbb, 0x38, 0x36, 0xce, 0xf7,
- 0x5d, 0x2f, 0x13, 0xec, 0xc8, 0x2d, 0x02, 0x8a,
- 0x2e, 0x72, 0xf0, 0xe5, 0x15, 0x9d, 0x72, 0xae,
- 0xfc, 0xb3, 0x4f, 0x02, 0xea, 0xe1, 0x09, 0xfe},
- {0x00, 0x00, 0x00, 0x00, 0xfa, 0x0a, 0x3d, 0xbc,
- 0xad, 0x16, 0x0c, 0xb6, 0xe7, 0x7c, 0x8b, 0x39,
- 0x9a, 0x43, 0xbb, 0xe3, 0xc2, 0x55, 0x15, 0x14,
- 0x75, 0xac, 0x90, 0x9b, 0x7f, 0x9a, 0x92, 0x00}},
- {{0x8b, 0xac, 0x70, 0x86, 0x29, 0x8f, 0x00, 0x23,
- 0x7b, 0x45, 0x30, 0xaa, 0xb8, 0x4c, 0xc7, 0x8d,
- 0x4e, 0x47, 0x85, 0xc6, 0x19, 0xe3, 0x96, 0xc2,
- 0x9a, 0xa0, 0x12, 0xed, 0x6f, 0xd7, 0x76, 0x16},
- {0x45, 0xaf, 0x7e, 0x33, 0xc7, 0x7f, 0x10, 0x6c,
- 0x7c, 0x9f, 0x29, 0xc1, 0xa8, 0x7e, 0x15, 0x84,
- 0xe7, 0x7d, 0xc0, 0x6d, 0xab, 0x71, 0x5d, 0xd0,
- 0x6b, 0x9f, 0x97, 0xab, 0xcb, 0x51, 0x0c, 0x9f}},
- {{0x9e, 0xc3, 0x92, 0xb4, 0x04, 0x9f, 0xc8, 0xbb,
- 0xdd, 0x9e, 0xc6, 0x05, 0xfd, 0x65, 0xec, 0x94,
- 0x7f, 0x2c, 0x16, 0xc4, 0x40, 0xac, 0x63, 0x7b,
- 0x7d, 0xb8, 0x0c, 0xe4, 0x5b, 0xe3, 0xa7, 0x0e},
- {0x43, 0xf4, 0x44, 0xe8, 0xcc, 0xc8, 0xd4, 0x54,
- 0x33, 0x37, 0x50, 0xf2, 0x87, 0x42, 0x2e, 0x00,
- 0x49, 0x60, 0x62, 0x02, 0xfd, 0x1a, 0x7c, 0xdb,
- 0x29, 0x6c, 0x6d, 0x54, 0x53, 0x08, 0xd1, 0xc8}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}},
- {{0x27, 0x59, 0xc7, 0x35, 0x60, 0x71, 0xa6, 0xf1,
- 0x79, 0xa5, 0xfd, 0x79, 0x16, 0xf3, 0x41, 0xf0,
- 0x57, 0xb4, 0x02, 0x97, 0x32, 0xe7, 0xde, 0x59,
- 0xe2, 0x2d, 0x9b, 0x11, 0xea, 0x2c, 0x35, 0x92},
- {0x27, 0x59, 0xc7, 0x35, 0x60, 0x71, 0xa6, 0xf1,
- 0x79, 0xa5, 0xfd, 0x79, 0x16, 0xf3, 0x41, 0xf0,
- 0x57, 0xb4, 0x02, 0x97, 0x32, 0xe7, 0xde, 0x59,
- 0xe2, 0x2d, 0x9b, 0x11, 0xea, 0x2c, 0x35, 0x92}},
- {{0x28, 0x56, 0xac, 0x0e, 0x4f, 0x98, 0x09, 0xf0,
- 0x49, 0xfa, 0x7f, 0x84, 0xac, 0x7e, 0x50, 0x5b,
- 0x17, 0x43, 0x14, 0x89, 0x9c, 0x53, 0xa8, 0x94,
- 0x30, 0xf2, 0x11, 0x4d, 0x92, 0x14, 0x27, 0xe8},
- {0x39, 0x7a, 0x84, 0x56, 0x79, 0x9d, 0xec, 0x26,
- 0x2c, 0x53, 0xc1, 0x94, 0xc9, 0x8d, 0x9e, 0x9d,
- 0x32, 0x1f, 0xdd, 0x84, 0x04, 0xe8, 0xe2, 0x0a,
- 0x6b, 0xbe, 0xbb, 0x42, 0x40, 0x67, 0x30, 0x6c}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x45, 0x51, 0x23, 0x19, 0x50, 0xb7, 0x5f, 0xc4,
- 0x40, 0x2d, 0xa1, 0x73, 0x2f, 0xc9, 0xbe, 0xbd},
- {0x27, 0x59, 0xc7, 0x35, 0x60, 0x71, 0xa6, 0xf1,
- 0x79, 0xa5, 0xfd, 0x79, 0x16, 0xf3, 0x41, 0xf0,
- 0x57, 0xb4, 0x02, 0x97, 0x32, 0xe7, 0xde, 0x59,
- 0xe2, 0x2d, 0x9b, 0x11, 0xea, 0x2c, 0x35, 0x92}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x40},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}},
- {{0x1c, 0xc4, 0xf7, 0xda, 0x0f, 0x65, 0xca, 0x39,
- 0x70, 0x52, 0x92, 0x8e, 0xc3, 0xc8, 0x15, 0xea,
- 0x7f, 0x10, 0x9e, 0x77, 0x4b, 0x6e, 0x2d, 0xdf,
- 0xe8, 0x30, 0x9d, 0xda, 0xe8, 0x9a, 0x65, 0xae},
- {0x02, 0xb0, 0x16, 0xb1, 0x1d, 0xc8, 0x57, 0x7b,
- 0xa2, 0x3a, 0xa2, 0xa3, 0x38, 0x5c, 0x8f, 0xeb,
- 0x66, 0x37, 0x91, 0xa8, 0x5f, 0xef, 0x04, 0xf6,
- 0x59, 0x75, 0xe1, 0xee, 0x92, 0xf6, 0x0e, 0x30}},
- {{0x8d, 0x76, 0x14, 0xa4, 0x14, 0x06, 0x9f, 0x9a,
- 0xdf, 0x4a, 0x85, 0xa7, 0x6b, 0xbf, 0x29, 0x6f,
- 0xbc, 0x34, 0x87, 0x5d, 0xeb, 0xbb, 0x2e, 0xa9,
- 0xc9, 0x1f, 0x58, 0xd6, 0x9a, 0x82, 0xa0, 0x56},
- {0xd4, 0xb9, 0xdb, 0x88, 0x1d, 0x04, 0xe9, 0x93,
- 0x8d, 0x3f, 0x20, 0xd5, 0x86, 0xa8, 0x83, 0x07,
- 0xdb, 0x09, 0xd8, 0x22, 0x1f, 0x7f, 0xf1, 0x71,
- 0xc8, 0xe7, 0x5d, 0x47, 0xaf, 0x8b, 0x72, 0xe9}},
- {{0x83, 0xb9, 0x39, 0xb2, 0xa4, 0xdf, 0x46, 0x87,
- 0xc2, 0xb8, 0xf1, 0xe6, 0x4c, 0xd1, 0xe2, 0xa9,
- 0xe4, 0x70, 0x30, 0x34, 0xbc, 0x52, 0x7c, 0x55,
- 0xa6, 0xec, 0x80, 0xa4, 0xe5, 0xd2, 0xdc, 0x73},
- {0x08, 0xf1, 0x03, 0xcf, 0x16, 0x73, 0xe8, 0x7d,
- 0xb6, 0x7e, 0x9b, 0xc0, 0xb4, 0xc2, 0xa5, 0x86,
- 0x02, 0x77, 0xd5, 0x27, 0x86, 0xa5, 0x15, 0xfb,
- 0xae, 0x9b, 0x8c, 0xa9, 0xf9, 0xf8, 0xa8, 0x4a}},
- {{0x8b, 0x00, 0x49, 0xdb, 0xfa, 0xf0, 0x1b, 0xa2,
- 0xed, 0x8a, 0x9a, 0x7a, 0x36, 0x78, 0x4a, 0xc7,
- 0xf7, 0xad, 0x39, 0xd0, 0x6c, 0x65, 0x7a, 0x41,
- 0xce, 0xd6, 0xd6, 0x4c, 0x20, 0x21, 0x6b, 0xc7},
- {0xc6, 0xca, 0x78, 0x1d, 0x32, 0x6c, 0x6c, 0x06,
- 0x91, 0xf2, 0x1a, 0xe8, 0x43, 0x16, 0xea, 0x04,
- 0x3c, 0x1f, 0x07, 0x85, 0xf7, 0x09, 0x22, 0x08,
- 0xba, 0x13, 0xfd, 0x78, 0x1e, 0x3f, 0x6f, 0x62}},
- {{0x25, 0x9b, 0x7c, 0xb0, 0xac, 0x72, 0x6f, 0xb2,
- 0xe3, 0x53, 0x84, 0x7a, 0x1a, 0x9a, 0x98, 0x9b,
- 0x44, 0xd3, 0x59, 0xd0, 0x8e, 0x57, 0x41, 0x40,
- 0x78, 0xa7, 0x30, 0x2f, 0x4c, 0x9c, 0xb9, 0x68},
- {0xb7, 0x75, 0x03, 0x63, 0x61, 0xc2, 0x48, 0x6e,
- 0x12, 0x3d, 0xbf, 0x4b, 0x27, 0xdf, 0xb1, 0x7a,
- 0xff, 0x4e, 0x31, 0x07, 0x83, 0xf4, 0x62, 0x5b,
- 0x19, 0xa5, 0xac, 0xa0, 0x32, 0x58, 0x0d, 0xa7}},
- {{0x43, 0x4f, 0x10, 0xa4, 0xca, 0xdb, 0x38, 0x67,
- 0xfa, 0xae, 0x96, 0xb5, 0x6d, 0x97, 0xff, 0x1f,
- 0xb6, 0x83, 0x43, 0xd3, 0xa0, 0x2d, 0x70, 0x7a,
- 0x64, 0x05, 0x4c, 0xa7, 0xc1, 0xa5, 0x21, 0x51},
- {0xe4, 0xf1, 0x23, 0x84, 0xe1, 0xb5, 0x9d, 0xf2,
- 0xb8, 0x73, 0x8b, 0x45, 0x2b, 0x35, 0x46, 0x38,
- 0x10, 0x2b, 0x50, 0xf8, 0x8b, 0x35, 0xcd, 0x34,
- 0xc8, 0x0e, 0xf6, 0xdb, 0x09, 0x35, 0xf0, 0xda}},
- {{0xdb, 0x21, 0x5c, 0x8d, 0x83, 0x1d, 0xb3, 0x34,
- 0xc7, 0x0e, 0x43, 0xa1, 0x58, 0x79, 0x67, 0x13,
- 0x1e, 0x86, 0x5d, 0x89, 0x63, 0xe6, 0x0a, 0x46,
- 0x5c, 0x02, 0x97, 0x1b, 0x62, 0x43, 0x86, 0xf5},
- {0xdb, 0x21, 0x5c, 0x8d, 0x83, 0x1d, 0xb3, 0x34,
- 0xc7, 0x0e, 0x43, 0xa1, 0x58, 0x79, 0x67, 0x13,
- 0x1e, 0x86, 0x5d, 0x89, 0x63, 0xe6, 0x0a, 0x46,
- 0x5c, 0x02, 0x97, 0x1b, 0x62, 0x43, 0x86, 0xf5}}
- };
- secp256k1_scalar_set_int(&one, 1);
- for (i = 0; i < 33; i++) {
- secp256k1_scalar_set_b32(&x, chal[i][0], &overflow);
- CHECK(!overflow);
- secp256k1_scalar_set_b32(&y, chal[i][1], &overflow);
- CHECK(!overflow);
- secp256k1_scalar_set_b32(&r1, res[i][0], &overflow);
- CHECK(!overflow);
- secp256k1_scalar_set_b32(&r2, res[i][1], &overflow);
- CHECK(!overflow);
- secp256k1_scalar_mul(&z, &x, &y);
- CHECK(!secp256k1_scalar_check_overflow(&z));
- CHECK(secp256k1_scalar_eq(&r1, &z));
- if (!secp256k1_scalar_is_zero(&y)) {
- secp256k1_scalar_inverse(&zz, &y);
- CHECK(!secp256k1_scalar_check_overflow(&zz));
-#if defined(USE_SCALAR_INV_NUM)
- secp256k1_scalar_inverse_var(&zzv, &y);
- CHECK(secp256k1_scalar_eq(&zzv, &zz));
-#endif
- secp256k1_scalar_mul(&z, &z, &zz);
- CHECK(!secp256k1_scalar_check_overflow(&z));
- CHECK(secp256k1_scalar_eq(&x, &z));
- secp256k1_scalar_mul(&zz, &zz, &y);
- CHECK(!secp256k1_scalar_check_overflow(&zz));
- CHECK(secp256k1_scalar_eq(&one, &zz));
- }
- secp256k1_scalar_mul(&z, &x, &x);
- CHECK(!secp256k1_scalar_check_overflow(&z));
- secp256k1_scalar_sqr(&zz, &x);
- CHECK(!secp256k1_scalar_check_overflow(&zz));
- CHECK(secp256k1_scalar_eq(&zz, &z));
- CHECK(secp256k1_scalar_eq(&r2, &zz));
- }
- }
-}
-
-/***** FIELD TESTS *****/
-
-void random_fe(secp256k1_fe *x) {
- unsigned char bin[32];
- do {
- secp256k1_rand256(bin);
- if (secp256k1_fe_set_b32(x, bin)) {
- return;
- }
- } while(1);
-}
-
-void random_fe_test(secp256k1_fe *x) {
- unsigned char bin[32];
- do {
- secp256k1_rand256_test(bin);
- if (secp256k1_fe_set_b32(x, bin)) {
- return;
- }
- } while(1);
-}
-
-void random_fe_non_zero(secp256k1_fe *nz) {
- int tries = 10;
- while (--tries >= 0) {
- random_fe(nz);
- secp256k1_fe_normalize(nz);
- if (!secp256k1_fe_is_zero(nz)) {
- break;
- }
- }
- /* Infinitesimal probability of spurious failure here */
- CHECK(tries >= 0);
-}
-
-void random_fe_non_square(secp256k1_fe *ns) {
- secp256k1_fe r;
- random_fe_non_zero(ns);
- if (secp256k1_fe_sqrt(&r, ns)) {
- secp256k1_fe_negate(ns, ns, 1);
- }
-}
-
-int check_fe_equal(const secp256k1_fe *a, const secp256k1_fe *b) {
- secp256k1_fe an = *a;
- secp256k1_fe bn = *b;
- secp256k1_fe_normalize_weak(&an);
- secp256k1_fe_normalize_var(&bn);
- return secp256k1_fe_equal_var(&an, &bn);
-}
-
-int check_fe_inverse(const secp256k1_fe *a, const secp256k1_fe *ai) {
- secp256k1_fe x;
- secp256k1_fe one = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1);
- secp256k1_fe_mul(&x, a, ai);
- return check_fe_equal(&x, &one);
-}
-
-void run_field_convert(void) {
- static const unsigned char b32[32] = {
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
- 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,
- 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x40
- };
- static const secp256k1_fe_storage fes = SECP256K1_FE_STORAGE_CONST(
- 0x00010203UL, 0x04050607UL, 0x11121314UL, 0x15161718UL,
- 0x22232425UL, 0x26272829UL, 0x33343536UL, 0x37383940UL
- );
- static const secp256k1_fe fe = SECP256K1_FE_CONST(
- 0x00010203UL, 0x04050607UL, 0x11121314UL, 0x15161718UL,
- 0x22232425UL, 0x26272829UL, 0x33343536UL, 0x37383940UL
- );
- secp256k1_fe fe2;
- unsigned char b322[32];
- secp256k1_fe_storage fes2;
- /* Check conversions to fe. */
- CHECK(secp256k1_fe_set_b32(&fe2, b32));
- CHECK(secp256k1_fe_equal_var(&fe, &fe2));
- secp256k1_fe_from_storage(&fe2, &fes);
- CHECK(secp256k1_fe_equal_var(&fe, &fe2));
- /* Check conversion from fe. */
- secp256k1_fe_get_b32(b322, &fe);
- CHECK(memcmp(b322, b32, 32) == 0);
- secp256k1_fe_to_storage(&fes2, &fe);
- CHECK(memcmp(&fes2, &fes, sizeof(fes)) == 0);
-}
-
-int fe_memcmp(const secp256k1_fe *a, const secp256k1_fe *b) {
- secp256k1_fe t = *b;
-#ifdef VERIFY
- t.magnitude = a->magnitude;
- t.normalized = a->normalized;
-#endif
- return memcmp(a, &t, sizeof(secp256k1_fe));
-}
-
-void run_field_misc(void) {
- secp256k1_fe x;
- secp256k1_fe y;
- secp256k1_fe z;
- secp256k1_fe q;
- secp256k1_fe fe5 = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 5);
- int i, j;
- for (i = 0; i < 5*count; i++) {
- secp256k1_fe_storage xs, ys, zs;
- random_fe(&x);
- random_fe_non_zero(&y);
- /* Test the fe equality and comparison operations. */
- CHECK(secp256k1_fe_cmp_var(&x, &x) == 0);
- CHECK(secp256k1_fe_equal_var(&x, &x));
- z = x;
- secp256k1_fe_add(&z,&y);
- /* Test fe conditional move; z is not normalized here. */
- q = x;
- secp256k1_fe_cmov(&x, &z, 0);
- VERIFY_CHECK(!x.normalized && x.magnitude == z.magnitude);
- secp256k1_fe_cmov(&x, &x, 1);
- CHECK(fe_memcmp(&x, &z) != 0);
- CHECK(fe_memcmp(&x, &q) == 0);
- secp256k1_fe_cmov(&q, &z, 1);
- VERIFY_CHECK(!q.normalized && q.magnitude == z.magnitude);
- CHECK(fe_memcmp(&q, &z) == 0);
- secp256k1_fe_normalize_var(&x);
- secp256k1_fe_normalize_var(&z);
- CHECK(!secp256k1_fe_equal_var(&x, &z));
- secp256k1_fe_normalize_var(&q);
- secp256k1_fe_cmov(&q, &z, (i&1));
- VERIFY_CHECK(q.normalized && q.magnitude == 1);
- for (j = 0; j < 6; j++) {
- secp256k1_fe_negate(&z, &z, j+1);
- secp256k1_fe_normalize_var(&q);
- secp256k1_fe_cmov(&q, &z, (j&1));
- VERIFY_CHECK(!q.normalized && q.magnitude == (j+2));
- }
- secp256k1_fe_normalize_var(&z);
- /* Test storage conversion and conditional moves. */
- secp256k1_fe_to_storage(&xs, &x);
- secp256k1_fe_to_storage(&ys, &y);
- secp256k1_fe_to_storage(&zs, &z);
- secp256k1_fe_storage_cmov(&zs, &xs, 0);
- secp256k1_fe_storage_cmov(&zs, &zs, 1);
- CHECK(memcmp(&xs, &zs, sizeof(xs)) != 0);
- secp256k1_fe_storage_cmov(&ys, &xs, 1);
- CHECK(memcmp(&xs, &ys, sizeof(xs)) == 0);
- secp256k1_fe_from_storage(&x, &xs);
- secp256k1_fe_from_storage(&y, &ys);
- secp256k1_fe_from_storage(&z, &zs);
- /* Test that mul_int, mul, and add agree. */
- secp256k1_fe_add(&y, &x);
- secp256k1_fe_add(&y, &x);
- z = x;
- secp256k1_fe_mul_int(&z, 3);
- CHECK(check_fe_equal(&y, &z));
- secp256k1_fe_add(&y, &x);
- secp256k1_fe_add(&z, &x);
- CHECK(check_fe_equal(&z, &y));
- z = x;
- secp256k1_fe_mul_int(&z, 5);
- secp256k1_fe_mul(&q, &x, &fe5);
- CHECK(check_fe_equal(&z, &q));
- secp256k1_fe_negate(&x, &x, 1);
- secp256k1_fe_add(&z, &x);
- secp256k1_fe_add(&q, &x);
- CHECK(check_fe_equal(&y, &z));
- CHECK(check_fe_equal(&q, &y));
- }
-}
-
-void run_field_inv(void) {
- secp256k1_fe x, xi, xii;
- int i;
- for (i = 0; i < 10*count; i++) {
- random_fe_non_zero(&x);
- secp256k1_fe_inv(&xi, &x);
- CHECK(check_fe_inverse(&x, &xi));
- secp256k1_fe_inv(&xii, &xi);
- CHECK(check_fe_equal(&x, &xii));
- }
-}
-
-void run_field_inv_var(void) {
- secp256k1_fe x, xi, xii;
- int i;
- for (i = 0; i < 10*count; i++) {
- random_fe_non_zero(&x);
- secp256k1_fe_inv_var(&xi, &x);
- CHECK(check_fe_inverse(&x, &xi));
- secp256k1_fe_inv_var(&xii, &xi);
- CHECK(check_fe_equal(&x, &xii));
- }
-}
-
-void run_field_inv_all_var(void) {
- secp256k1_fe x[16], xi[16], xii[16];
- int i;
- /* Check it's safe to call for 0 elements */
- secp256k1_fe_inv_all_var(xi, x, 0);
- for (i = 0; i < count; i++) {
- size_t j;
- size_t len = secp256k1_rand_int(15) + 1;
- for (j = 0; j < len; j++) {
- random_fe_non_zero(&x[j]);
- }
- secp256k1_fe_inv_all_var(xi, x, len);
- for (j = 0; j < len; j++) {
- CHECK(check_fe_inverse(&x[j], &xi[j]));
- }
- secp256k1_fe_inv_all_var(xii, xi, len);
- for (j = 0; j < len; j++) {
- CHECK(check_fe_equal(&x[j], &xii[j]));
- }
- }
-}
-
-void run_sqr(void) {
- secp256k1_fe x, s;
-
- {
- int i;
- secp256k1_fe_set_int(&x, 1);
- secp256k1_fe_negate(&x, &x, 1);
-
- for (i = 1; i <= 512; ++i) {
- secp256k1_fe_mul_int(&x, 2);
- secp256k1_fe_normalize(&x);
- secp256k1_fe_sqr(&s, &x);
- }
- }
-}
-
-void test_sqrt(const secp256k1_fe *a, const secp256k1_fe *k) {
- secp256k1_fe r1, r2;
- int v = secp256k1_fe_sqrt(&r1, a);
- CHECK((v == 0) == (k == NULL));
-
- if (k != NULL) {
- /* Check that the returned root is +/- the given known answer */
- secp256k1_fe_negate(&r2, &r1, 1);
- secp256k1_fe_add(&r1, k); secp256k1_fe_add(&r2, k);
- secp256k1_fe_normalize(&r1); secp256k1_fe_normalize(&r2);
- CHECK(secp256k1_fe_is_zero(&r1) || secp256k1_fe_is_zero(&r2));
- }
-}
-
-void run_sqrt(void) {
- secp256k1_fe ns, x, s, t;
- int i;
-
- /* Check sqrt(0) is 0 */
- secp256k1_fe_set_int(&x, 0);
- secp256k1_fe_sqr(&s, &x);
- test_sqrt(&s, &x);
-
- /* Check sqrt of small squares (and their negatives) */
- for (i = 1; i <= 100; i++) {
- secp256k1_fe_set_int(&x, i);
- secp256k1_fe_sqr(&s, &x);
- test_sqrt(&s, &x);
- secp256k1_fe_negate(&t, &s, 1);
- test_sqrt(&t, NULL);
- }
-
- /* Consistency checks for large random values */
- for (i = 0; i < 10; i++) {
- int j;
- random_fe_non_square(&ns);
- for (j = 0; j < count; j++) {
- random_fe(&x);
- secp256k1_fe_sqr(&s, &x);
- test_sqrt(&s, &x);
- secp256k1_fe_negate(&t, &s, 1);
- test_sqrt(&t, NULL);
- secp256k1_fe_mul(&t, &s, &ns);
- test_sqrt(&t, NULL);
- }
- }
-}
-
-/***** GROUP TESTS *****/
-
-void ge_equals_ge(const secp256k1_ge *a, const secp256k1_ge *b) {
- CHECK(a->infinity == b->infinity);
- if (a->infinity) {
- return;
- }
- CHECK(secp256k1_fe_equal_var(&a->x, &b->x));
- CHECK(secp256k1_fe_equal_var(&a->y, &b->y));
-}
-
-/* This compares jacobian points including their Z, not just their geometric meaning. */
-int gej_xyz_equals_gej(const secp256k1_gej *a, const secp256k1_gej *b) {
- secp256k1_gej a2;
- secp256k1_gej b2;
- int ret = 1;
- ret &= a->infinity == b->infinity;
- if (ret && !a->infinity) {
- a2 = *a;
- b2 = *b;
- secp256k1_fe_normalize(&a2.x);
- secp256k1_fe_normalize(&a2.y);
- secp256k1_fe_normalize(&a2.z);
- secp256k1_fe_normalize(&b2.x);
- secp256k1_fe_normalize(&b2.y);
- secp256k1_fe_normalize(&b2.z);
- ret &= secp256k1_fe_cmp_var(&a2.x, &b2.x) == 0;
- ret &= secp256k1_fe_cmp_var(&a2.y, &b2.y) == 0;
- ret &= secp256k1_fe_cmp_var(&a2.z, &b2.z) == 0;
- }
- return ret;
-}
-
-void ge_equals_gej(const secp256k1_ge *a, const secp256k1_gej *b) {
- secp256k1_fe z2s;
- secp256k1_fe u1, u2, s1, s2;
- CHECK(a->infinity == b->infinity);
- if (a->infinity) {
- return;
- }
- /* Check a.x * b.z^2 == b.x && a.y * b.z^3 == b.y, to avoid inverses. */
- secp256k1_fe_sqr(&z2s, &b->z);
- secp256k1_fe_mul(&u1, &a->x, &z2s);
- u2 = b->x; secp256k1_fe_normalize_weak(&u2);
- secp256k1_fe_mul(&s1, &a->y, &z2s); secp256k1_fe_mul(&s1, &s1, &b->z);
- s2 = b->y; secp256k1_fe_normalize_weak(&s2);
- CHECK(secp256k1_fe_equal_var(&u1, &u2));
- CHECK(secp256k1_fe_equal_var(&s1, &s2));
-}
-
-void test_ge(void) {
- int i, i1;
-#ifdef USE_ENDOMORPHISM
- int runs = 6;
-#else
- int runs = 4;
-#endif
- /* Points: (infinity, p1, p1, -p1, -p1, p2, p2, -p2, -p2, p3, p3, -p3, -p3, p4, p4, -p4, -p4).
- * The second in each pair of identical points uses a random Z coordinate in the Jacobian form.
- * All magnitudes are randomized.
- * All 17*17 combinations of points are added to each other, using all applicable methods.
- *
- * When the endomorphism code is compiled in, p5 = lambda*p1 and p6 = lambda^2*p1 are added as well.
- */
- secp256k1_ge *ge = (secp256k1_ge *)malloc(sizeof(secp256k1_ge) * (1 + 4 * runs));
- secp256k1_gej *gej = (secp256k1_gej *)malloc(sizeof(secp256k1_gej) * (1 + 4 * runs));
- secp256k1_fe *zinv = (secp256k1_fe *)malloc(sizeof(secp256k1_fe) * (1 + 4 * runs));
- secp256k1_fe zf;
- secp256k1_fe zfi2, zfi3;
-
- secp256k1_gej_set_infinity(&gej[0]);
- secp256k1_ge_clear(&ge[0]);
- secp256k1_ge_set_gej_var(&ge[0], &gej[0]);
- for (i = 0; i < runs; i++) {
- int j;
- secp256k1_ge g;
- random_group_element_test(&g);
-#ifdef USE_ENDOMORPHISM
- if (i >= runs - 2) {
- secp256k1_ge_mul_lambda(&g, &ge[1]);
- }
- if (i >= runs - 1) {
- secp256k1_ge_mul_lambda(&g, &g);
- }
-#endif
- ge[1 + 4 * i] = g;
- ge[2 + 4 * i] = g;
- secp256k1_ge_neg(&ge[3 + 4 * i], &g);
- secp256k1_ge_neg(&ge[4 + 4 * i], &g);
- secp256k1_gej_set_ge(&gej[1 + 4 * i], &ge[1 + 4 * i]);
- random_group_element_jacobian_test(&gej[2 + 4 * i], &ge[2 + 4 * i]);
- secp256k1_gej_set_ge(&gej[3 + 4 * i], &ge[3 + 4 * i]);
- random_group_element_jacobian_test(&gej[4 + 4 * i], &ge[4 + 4 * i]);
- for (j = 0; j < 4; j++) {
- random_field_element_magnitude(&ge[1 + j + 4 * i].x);
- random_field_element_magnitude(&ge[1 + j + 4 * i].y);
- random_field_element_magnitude(&gej[1 + j + 4 * i].x);
- random_field_element_magnitude(&gej[1 + j + 4 * i].y);
- random_field_element_magnitude(&gej[1 + j + 4 * i].z);
- }
- }
-
- /* Compute z inverses. */
- {
- secp256k1_fe *zs = malloc(sizeof(secp256k1_fe) * (1 + 4 * runs));
- for (i = 0; i < 4 * runs + 1; i++) {
- if (i == 0) {
- /* The point at infinity does not have a meaningful z inverse. Any should do. */
- do {
- random_field_element_test(&zs[i]);
- } while(secp256k1_fe_is_zero(&zs[i]));
- } else {
- zs[i] = gej[i].z;
- }
- }
- secp256k1_fe_inv_all_var(zinv, zs, 4 * runs + 1);
- free(zs);
- }
-
- /* Generate random zf, and zfi2 = 1/zf^2, zfi3 = 1/zf^3 */
- do {
- random_field_element_test(&zf);
- } while(secp256k1_fe_is_zero(&zf));
- random_field_element_magnitude(&zf);
- secp256k1_fe_inv_var(&zfi3, &zf);
- secp256k1_fe_sqr(&zfi2, &zfi3);
- secp256k1_fe_mul(&zfi3, &zfi3, &zfi2);
-
- for (i1 = 0; i1 < 1 + 4 * runs; i1++) {
- int i2;
- for (i2 = 0; i2 < 1 + 4 * runs; i2++) {
- /* Compute reference result using gej + gej (var). */
- secp256k1_gej refj, resj;
- secp256k1_ge ref;
- secp256k1_fe zr;
- secp256k1_gej_add_var(&refj, &gej[i1], &gej[i2], secp256k1_gej_is_infinity(&gej[i1]) ? NULL : &zr);
- /* Check Z ratio. */
- if (!secp256k1_gej_is_infinity(&gej[i1]) && !secp256k1_gej_is_infinity(&refj)) {
- secp256k1_fe zrz; secp256k1_fe_mul(&zrz, &zr, &gej[i1].z);
- CHECK(secp256k1_fe_equal_var(&zrz, &refj.z));
- }
- secp256k1_ge_set_gej_var(&ref, &refj);
-
- /* Test gej + ge with Z ratio result (var). */
- secp256k1_gej_add_ge_var(&resj, &gej[i1], &ge[i2], secp256k1_gej_is_infinity(&gej[i1]) ? NULL : &zr);
- ge_equals_gej(&ref, &resj);
- if (!secp256k1_gej_is_infinity(&gej[i1]) && !secp256k1_gej_is_infinity(&resj)) {
- secp256k1_fe zrz; secp256k1_fe_mul(&zrz, &zr, &gej[i1].z);
- CHECK(secp256k1_fe_equal_var(&zrz, &resj.z));
- }
-
- /* Test gej + ge (var, with additional Z factor). */
- {
- secp256k1_ge ge2_zfi = ge[i2]; /* the second term with x and y rescaled for z = 1/zf */
- secp256k1_fe_mul(&ge2_zfi.x, &ge2_zfi.x, &zfi2);
- secp256k1_fe_mul(&ge2_zfi.y, &ge2_zfi.y, &zfi3);
- random_field_element_magnitude(&ge2_zfi.x);
- random_field_element_magnitude(&ge2_zfi.y);
- secp256k1_gej_add_zinv_var(&resj, &gej[i1], &ge2_zfi, &zf);
- ge_equals_gej(&ref, &resj);
- }
-
- /* Test gej + ge (const). */
- if (i2 != 0) {
- /* secp256k1_gej_add_ge does not support its second argument being infinity. */
- secp256k1_gej_add_ge(&resj, &gej[i1], &ge[i2]);
- ge_equals_gej(&ref, &resj);
- }
-
- /* Test doubling (var). */
- if ((i1 == 0 && i2 == 0) || ((i1 + 3)/4 == (i2 + 3)/4 && ((i1 + 3)%4)/2 == ((i2 + 3)%4)/2)) {
- secp256k1_fe zr2;
- /* Normal doubling with Z ratio result. */
- secp256k1_gej_double_var(&resj, &gej[i1], &zr2);
- ge_equals_gej(&ref, &resj);
- /* Check Z ratio. */
- secp256k1_fe_mul(&zr2, &zr2, &gej[i1].z);
- CHECK(secp256k1_fe_equal_var(&zr2, &resj.z));
- /* Normal doubling. */
- secp256k1_gej_double_var(&resj, &gej[i2], NULL);
- ge_equals_gej(&ref, &resj);
- }
-
- /* Test adding opposites. */
- if ((i1 == 0 && i2 == 0) || ((i1 + 3)/4 == (i2 + 3)/4 && ((i1 + 3)%4)/2 != ((i2 + 3)%4)/2)) {
- CHECK(secp256k1_ge_is_infinity(&ref));
- }
-
- /* Test adding infinity. */
- if (i1 == 0) {
- CHECK(secp256k1_ge_is_infinity(&ge[i1]));
- CHECK(secp256k1_gej_is_infinity(&gej[i1]));
- ge_equals_gej(&ref, &gej[i2]);
- }
- if (i2 == 0) {
- CHECK(secp256k1_ge_is_infinity(&ge[i2]));
- CHECK(secp256k1_gej_is_infinity(&gej[i2]));
- ge_equals_gej(&ref, &gej[i1]);
- }
- }
- }
-
- /* Test adding all points together in random order equals infinity. */
- {
- secp256k1_gej sum = SECP256K1_GEJ_CONST_INFINITY;
- secp256k1_gej *gej_shuffled = (secp256k1_gej *)malloc((4 * runs + 1) * sizeof(secp256k1_gej));
- for (i = 0; i < 4 * runs + 1; i++) {
- gej_shuffled[i] = gej[i];
- }
- for (i = 0; i < 4 * runs + 1; i++) {
- int swap = i + secp256k1_rand_int(4 * runs + 1 - i);
- if (swap != i) {
- secp256k1_gej t = gej_shuffled[i];
- gej_shuffled[i] = gej_shuffled[swap];
- gej_shuffled[swap] = t;
- }
- }
- for (i = 0; i < 4 * runs + 1; i++) {
- secp256k1_gej_add_var(&sum, &sum, &gej_shuffled[i], NULL);
- }
- CHECK(secp256k1_gej_is_infinity(&sum));
- free(gej_shuffled);
- }
-
- /* Test batch gej -> ge conversion with and without known z ratios. */
- {
- secp256k1_fe *zr = (secp256k1_fe *)malloc((4 * runs + 1) * sizeof(secp256k1_fe));
- secp256k1_ge *ge_set_table = (secp256k1_ge *)malloc((4 * runs + 1) * sizeof(secp256k1_ge));
- secp256k1_ge *ge_set_all = (secp256k1_ge *)malloc((4 * runs + 1) * sizeof(secp256k1_ge));
- for (i = 0; i < 4 * runs + 1; i++) {
- /* Compute gej[i + 1].z / gez[i].z (with gej[n].z taken to be 1). */
- if (i < 4 * runs) {
- secp256k1_fe_mul(&zr[i + 1], &zinv[i], &gej[i + 1].z);
- }
- }
- secp256k1_ge_set_table_gej_var(ge_set_table, gej, zr, 4 * runs + 1);
- secp256k1_ge_set_all_gej_var(ge_set_all, gej, 4 * runs + 1, &ctx->error_callback);
- for (i = 0; i < 4 * runs + 1; i++) {
- secp256k1_fe s;
- random_fe_non_zero(&s);
- secp256k1_gej_rescale(&gej[i], &s);
- ge_equals_gej(&ge_set_table[i], &gej[i]);
- ge_equals_gej(&ge_set_all[i], &gej[i]);
- }
- free(ge_set_table);
- free(ge_set_all);
- free(zr);
- }
-
- free(ge);
- free(gej);
- free(zinv);
-}
-
-void test_add_neg_y_diff_x(void) {
- /* The point of this test is to check that we can add two points
- * whose y-coordinates are negatives of each other but whose x
- * coordinates differ. If the x-coordinates were the same, these
- * points would be negatives of each other and their sum is
- * infinity. This is cool because it "covers up" any degeneracy
- * in the addition algorithm that would cause the xy coordinates
- * of the sum to be wrong (since infinity has no xy coordinates).
- * HOWEVER, if the x-coordinates are different, infinity is the
- * wrong answer, and such degeneracies are exposed. This is the
- * root of https://github.com/bitcoin-core/secp256k1/issues/257
- * which this test is a regression test for.
- *
- * These points were generated in sage as
- * # secp256k1 params
- * F = FiniteField (0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
- * C = EllipticCurve ([F (0), F (7)])
- * G = C.lift_x(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
- * N = FiniteField(G.order())
- *
- * # endomorphism values (lambda is 1^{1/3} in N, beta is 1^{1/3} in F)
- * x = polygen(N)
- * lam = (1 - x^3).roots()[1][0]
- *
- * # random "bad pair"
- * P = C.random_element()
- * Q = -int(lam) * P
- * print " P: %x %x" % P.xy()
- * print " Q: %x %x" % Q.xy()
- * print "P + Q: %x %x" % (P + Q).xy()
- */
- secp256k1_gej aj = SECP256K1_GEJ_CONST(
- 0x8d24cd95, 0x0a355af1, 0x3c543505, 0x44238d30,
- 0x0643d79f, 0x05a59614, 0x2f8ec030, 0xd58977cb,
- 0x001e337a, 0x38093dcd, 0x6c0f386d, 0x0b1293a8,
- 0x4d72c879, 0xd7681924, 0x44e6d2f3, 0x9190117d
- );
- secp256k1_gej bj = SECP256K1_GEJ_CONST(
- 0xc7b74206, 0x1f788cd9, 0xabd0937d, 0x164a0d86,
- 0x95f6ff75, 0xf19a4ce9, 0xd013bd7b, 0xbf92d2a7,
- 0xffe1cc85, 0xc7f6c232, 0x93f0c792, 0xf4ed6c57,
- 0xb28d3786, 0x2897e6db, 0xbb192d0b, 0x6e6feab2
- );
- secp256k1_gej sumj = SECP256K1_GEJ_CONST(
- 0x671a63c0, 0x3efdad4c, 0x389a7798, 0x24356027,
- 0xb3d69010, 0x278625c3, 0x5c86d390, 0x184a8f7a,
- 0x5f6409c2, 0x2ce01f2b, 0x511fd375, 0x25071d08,
- 0xda651801, 0x70e95caf, 0x8f0d893c, 0xbed8fbbe
- );
- secp256k1_ge b;
- secp256k1_gej resj;
- secp256k1_ge res;
- secp256k1_ge_set_gej(&b, &bj);
-
- secp256k1_gej_add_var(&resj, &aj, &bj, NULL);
- secp256k1_ge_set_gej(&res, &resj);
- ge_equals_gej(&res, &sumj);
-
- secp256k1_gej_add_ge(&resj, &aj, &b);
- secp256k1_ge_set_gej(&res, &resj);
- ge_equals_gej(&res, &sumj);
-
- secp256k1_gej_add_ge_var(&resj, &aj, &b, NULL);
- secp256k1_ge_set_gej(&res, &resj);
- ge_equals_gej(&res, &sumj);
-}
-
-void run_ge(void) {
- int i;
- for (i = 0; i < count * 32; i++) {
- test_ge();
- }
- test_add_neg_y_diff_x();
-}
-
-void test_ec_combine(void) {
- secp256k1_scalar sum = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
- secp256k1_pubkey data[6];
- const secp256k1_pubkey* d[6];
- secp256k1_pubkey sd;
- secp256k1_pubkey sd2;
- secp256k1_gej Qj;
- secp256k1_ge Q;
- int i;
- for (i = 1; i <= 6; i++) {
- secp256k1_scalar s;
- random_scalar_order_test(&s);
- secp256k1_scalar_add(&sum, &sum, &s);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &Qj, &s);
- secp256k1_ge_set_gej(&Q, &Qj);
- secp256k1_pubkey_save(&data[i - 1], &Q);
- d[i - 1] = &data[i - 1];
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &Qj, &sum);
- secp256k1_ge_set_gej(&Q, &Qj);
- secp256k1_pubkey_save(&sd, &Q);
- CHECK(secp256k1_ec_pubkey_combine(ctx, &sd2, d, i) == 1);
- CHECK(memcmp(&sd, &sd2, sizeof(sd)) == 0);
- }
-}
-
-void run_ec_combine(void) {
- int i;
- for (i = 0; i < count * 8; i++) {
- test_ec_combine();
- }
-}
-
-void test_group_decompress(const secp256k1_fe* x) {
- /* The input itself, normalized. */
- secp256k1_fe fex = *x;
- secp256k1_fe fez;
- /* Results of set_xquad_var, set_xo_var(..., 0), set_xo_var(..., 1). */
- secp256k1_ge ge_quad, ge_even, ge_odd;
- secp256k1_gej gej_quad;
- /* Return values of the above calls. */
- int res_quad, res_even, res_odd;
-
- secp256k1_fe_normalize_var(&fex);
-
- res_quad = secp256k1_ge_set_xquad(&ge_quad, &fex);
- res_even = secp256k1_ge_set_xo_var(&ge_even, &fex, 0);
- res_odd = secp256k1_ge_set_xo_var(&ge_odd, &fex, 1);
-
- CHECK(res_quad == res_even);
- CHECK(res_quad == res_odd);
-
- if (res_quad) {
- secp256k1_fe_normalize_var(&ge_quad.x);
- secp256k1_fe_normalize_var(&ge_odd.x);
- secp256k1_fe_normalize_var(&ge_even.x);
- secp256k1_fe_normalize_var(&ge_quad.y);
- secp256k1_fe_normalize_var(&ge_odd.y);
- secp256k1_fe_normalize_var(&ge_even.y);
-
- /* No infinity allowed. */
- CHECK(!ge_quad.infinity);
- CHECK(!ge_even.infinity);
- CHECK(!ge_odd.infinity);
-
- /* Check that the x coordinates check out. */
- CHECK(secp256k1_fe_equal_var(&ge_quad.x, x));
- CHECK(secp256k1_fe_equal_var(&ge_even.x, x));
- CHECK(secp256k1_fe_equal_var(&ge_odd.x, x));
-
- /* Check that the Y coordinate result in ge_quad is a square. */
- CHECK(secp256k1_fe_is_quad_var(&ge_quad.y));
-
- /* Check odd/even Y in ge_odd, ge_even. */
- CHECK(secp256k1_fe_is_odd(&ge_odd.y));
- CHECK(!secp256k1_fe_is_odd(&ge_even.y));
-
- /* Check secp256k1_gej_has_quad_y_var. */
- secp256k1_gej_set_ge(&gej_quad, &ge_quad);
- CHECK(secp256k1_gej_has_quad_y_var(&gej_quad));
- do {
- random_fe_test(&fez);
- } while (secp256k1_fe_is_zero(&fez));
- secp256k1_gej_rescale(&gej_quad, &fez);
- CHECK(secp256k1_gej_has_quad_y_var(&gej_quad));
- secp256k1_gej_neg(&gej_quad, &gej_quad);
- CHECK(!secp256k1_gej_has_quad_y_var(&gej_quad));
- do {
- random_fe_test(&fez);
- } while (secp256k1_fe_is_zero(&fez));
- secp256k1_gej_rescale(&gej_quad, &fez);
- CHECK(!secp256k1_gej_has_quad_y_var(&gej_quad));
- secp256k1_gej_neg(&gej_quad, &gej_quad);
- CHECK(secp256k1_gej_has_quad_y_var(&gej_quad));
- }
-}
-
-void run_group_decompress(void) {
- int i;
- for (i = 0; i < count * 4; i++) {
- secp256k1_fe fe;
- random_fe_test(&fe);
- test_group_decompress(&fe);
- }
-}
-
-/***** ECMULT TESTS *****/
-
-void run_ecmult_chain(void) {
- /* random starting point A (on the curve) */
- secp256k1_gej a = SECP256K1_GEJ_CONST(
- 0x8b30bbe9, 0xae2a9906, 0x96b22f67, 0x0709dff3,
- 0x727fd8bc, 0x04d3362c, 0x6c7bf458, 0xe2846004,
- 0xa357ae91, 0x5c4a6528, 0x1309edf2, 0x0504740f,
- 0x0eb33439, 0x90216b4f, 0x81063cb6, 0x5f2f7e0f
- );
- /* two random initial factors xn and gn */
- secp256k1_scalar xn = SECP256K1_SCALAR_CONST(
- 0x84cc5452, 0xf7fde1ed, 0xb4d38a8c, 0xe9b1b84c,
- 0xcef31f14, 0x6e569be9, 0x705d357a, 0x42985407
- );
- secp256k1_scalar gn = SECP256K1_SCALAR_CONST(
- 0xa1e58d22, 0x553dcd42, 0xb2398062, 0x5d4c57a9,
- 0x6e9323d4, 0x2b3152e5, 0xca2c3990, 0xedc7c9de
- );
- /* two small multipliers to be applied to xn and gn in every iteration: */
- static const secp256k1_scalar xf = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0x1337);
- static const secp256k1_scalar gf = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0x7113);
- /* accumulators with the resulting coefficients to A and G */
- secp256k1_scalar ae = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 1);
- secp256k1_scalar ge = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
- /* actual points */
- secp256k1_gej x;
- secp256k1_gej x2;
- int i;
-
- /* the point being computed */
- x = a;
- for (i = 0; i < 200*count; i++) {
- /* in each iteration, compute X = xn*X + gn*G; */
- secp256k1_ecmult(&ctx->ecmult_ctx, &x, &x, &xn, &gn);
- /* also compute ae and ge: the actual accumulated factors for A and G */
- /* if X was (ae*A+ge*G), xn*X + gn*G results in (xn*ae*A + (xn*ge+gn)*G) */
- secp256k1_scalar_mul(&ae, &ae, &xn);
- secp256k1_scalar_mul(&ge, &ge, &xn);
- secp256k1_scalar_add(&ge, &ge, &gn);
- /* modify xn and gn */
- secp256k1_scalar_mul(&xn, &xn, &xf);
- secp256k1_scalar_mul(&gn, &gn, &gf);
-
- /* verify */
- if (i == 19999) {
- /* expected result after 19999 iterations */
- secp256k1_gej rp = SECP256K1_GEJ_CONST(
- 0xD6E96687, 0xF9B10D09, 0x2A6F3543, 0x9D86CEBE,
- 0xA4535D0D, 0x409F5358, 0x6440BD74, 0xB933E830,
- 0xB95CBCA2, 0xC77DA786, 0x539BE8FD, 0x53354D2D,
- 0x3B4F566A, 0xE6580454, 0x07ED6015, 0xEE1B2A88
- );
-
- secp256k1_gej_neg(&rp, &rp);
- secp256k1_gej_add_var(&rp, &rp, &x, NULL);
- CHECK(secp256k1_gej_is_infinity(&rp));
- }
- }
- /* redo the computation, but directly with the resulting ae and ge coefficients: */
- secp256k1_ecmult(&ctx->ecmult_ctx, &x2, &a, &ae, &ge);
- secp256k1_gej_neg(&x2, &x2);
- secp256k1_gej_add_var(&x2, &x2, &x, NULL);
- CHECK(secp256k1_gej_is_infinity(&x2));
-}
-
-void test_point_times_order(const secp256k1_gej *point) {
- /* X * (point + G) + (order-X) * (pointer + G) = 0 */
- secp256k1_scalar x;
- secp256k1_scalar nx;
- secp256k1_scalar zero = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
- secp256k1_scalar one = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 1);
- secp256k1_gej res1, res2;
- secp256k1_ge res3;
- unsigned char pub[65];
- size_t psize = 65;
- random_scalar_order_test(&x);
- secp256k1_scalar_negate(&nx, &x);
- secp256k1_ecmult(&ctx->ecmult_ctx, &res1, point, &x, &x); /* calc res1 = x * point + x * G; */
- secp256k1_ecmult(&ctx->ecmult_ctx, &res2, point, &nx, &nx); /* calc res2 = (order - x) * point + (order - x) * G; */
- secp256k1_gej_add_var(&res1, &res1, &res2, NULL);
- CHECK(secp256k1_gej_is_infinity(&res1));
- CHECK(secp256k1_gej_is_valid_var(&res1) == 0);
- secp256k1_ge_set_gej(&res3, &res1);
- CHECK(secp256k1_ge_is_infinity(&res3));
- CHECK(secp256k1_ge_is_valid_var(&res3) == 0);
- CHECK(secp256k1_eckey_pubkey_serialize(&res3, pub, &psize, 0) == 0);
- psize = 65;
- CHECK(secp256k1_eckey_pubkey_serialize(&res3, pub, &psize, 1) == 0);
- /* check zero/one edge cases */
- secp256k1_ecmult(&ctx->ecmult_ctx, &res1, point, &zero, &zero);
- secp256k1_ge_set_gej(&res3, &res1);
- CHECK(secp256k1_ge_is_infinity(&res3));
- secp256k1_ecmult(&ctx->ecmult_ctx, &res1, point, &one, &zero);
- secp256k1_ge_set_gej(&res3, &res1);
- ge_equals_gej(&res3, point);
- secp256k1_ecmult(&ctx->ecmult_ctx, &res1, point, &zero, &one);
- secp256k1_ge_set_gej(&res3, &res1);
- ge_equals_ge(&res3, &secp256k1_ge_const_g);
-}
-
-void run_point_times_order(void) {
- int i;
- secp256k1_fe x = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 2);
- static const secp256k1_fe xr = SECP256K1_FE_CONST(
- 0x7603CB59, 0xB0EF6C63, 0xFE608479, 0x2A0C378C,
- 0xDB3233A8, 0x0F8A9A09, 0xA877DEAD, 0x31B38C45
- );
- for (i = 0; i < 500; i++) {
- secp256k1_ge p;
- if (secp256k1_ge_set_xo_var(&p, &x, 1)) {
- secp256k1_gej j;
- CHECK(secp256k1_ge_is_valid_var(&p));
- secp256k1_gej_set_ge(&j, &p);
- CHECK(secp256k1_gej_is_valid_var(&j));
- test_point_times_order(&j);
- }
- secp256k1_fe_sqr(&x, &x);
- }
- secp256k1_fe_normalize_var(&x);
- CHECK(secp256k1_fe_equal_var(&x, &xr));
-}
-
-void ecmult_const_random_mult(void) {
- /* random starting point A (on the curve) */
- secp256k1_ge a = SECP256K1_GE_CONST(
- 0x6d986544, 0x57ff52b8, 0xcf1b8126, 0x5b802a5b,
- 0xa97f9263, 0xb1e88044, 0x93351325, 0x91bc450a,
- 0x535c59f7, 0x325e5d2b, 0xc391fbe8, 0x3c12787c,
- 0x337e4a98, 0xe82a9011, 0x0123ba37, 0xdd769c7d
- );
- /* random initial factor xn */
- secp256k1_scalar xn = SECP256K1_SCALAR_CONST(
- 0x649d4f77, 0xc4242df7, 0x7f2079c9, 0x14530327,
- 0xa31b876a, 0xd2d8ce2a, 0x2236d5c6, 0xd7b2029b
- );
- /* expected xn * A (from sage) */
- secp256k1_ge expected_b = SECP256K1_GE_CONST(
- 0x23773684, 0x4d209dc7, 0x098a786f, 0x20d06fcd,
- 0x070a38bf, 0xc11ac651, 0x03004319, 0x1e2a8786,
- 0xed8c3b8e, 0xc06dd57b, 0xd06ea66e, 0x45492b0f,
- 0xb84e4e1b, 0xfb77e21f, 0x96baae2a, 0x63dec956
- );
- secp256k1_gej b;
- secp256k1_ecmult_const(&b, &a, &xn);
-
- CHECK(secp256k1_ge_is_valid_var(&a));
- ge_equals_gej(&expected_b, &b);
-}
-
-void ecmult_const_commutativity(void) {
- secp256k1_scalar a;
- secp256k1_scalar b;
- secp256k1_gej res1;
- secp256k1_gej res2;
- secp256k1_ge mid1;
- secp256k1_ge mid2;
- random_scalar_order_test(&a);
- random_scalar_order_test(&b);
-
- secp256k1_ecmult_const(&res1, &secp256k1_ge_const_g, &a);
- secp256k1_ecmult_const(&res2, &secp256k1_ge_const_g, &b);
- secp256k1_ge_set_gej(&mid1, &res1);
- secp256k1_ge_set_gej(&mid2, &res2);
- secp256k1_ecmult_const(&res1, &mid1, &b);
- secp256k1_ecmult_const(&res2, &mid2, &a);
- secp256k1_ge_set_gej(&mid1, &res1);
- secp256k1_ge_set_gej(&mid2, &res2);
- ge_equals_ge(&mid1, &mid2);
-}
-
-void ecmult_const_mult_zero_one(void) {
- secp256k1_scalar zero = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
- secp256k1_scalar one = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 1);
- secp256k1_scalar negone;
- secp256k1_gej res1;
- secp256k1_ge res2;
- secp256k1_ge point;
- secp256k1_scalar_negate(&negone, &one);
-
- random_group_element_test(&point);
- secp256k1_ecmult_const(&res1, &point, &zero);
- secp256k1_ge_set_gej(&res2, &res1);
- CHECK(secp256k1_ge_is_infinity(&res2));
- secp256k1_ecmult_const(&res1, &point, &one);
- secp256k1_ge_set_gej(&res2, &res1);
- ge_equals_ge(&res2, &point);
- secp256k1_ecmult_const(&res1, &point, &negone);
- secp256k1_gej_neg(&res1, &res1);
- secp256k1_ge_set_gej(&res2, &res1);
- ge_equals_ge(&res2, &point);
-}
-
-void ecmult_const_chain_multiply(void) {
- /* Check known result (randomly generated test problem from sage) */
- const secp256k1_scalar scalar = SECP256K1_SCALAR_CONST(
- 0x4968d524, 0x2abf9b7a, 0x466abbcf, 0x34b11b6d,
- 0xcd83d307, 0x827bed62, 0x05fad0ce, 0x18fae63b
- );
- const secp256k1_gej expected_point = SECP256K1_GEJ_CONST(
- 0x5494c15d, 0x32099706, 0xc2395f94, 0x348745fd,
- 0x757ce30e, 0x4e8c90fb, 0xa2bad184, 0xf883c69f,
- 0x5d195d20, 0xe191bf7f, 0x1be3e55f, 0x56a80196,
- 0x6071ad01, 0xf1462f66, 0xc997fa94, 0xdb858435
- );
- secp256k1_gej point;
- secp256k1_ge res;
- int i;
-
- secp256k1_gej_set_ge(&point, &secp256k1_ge_const_g);
- for (i = 0; i < 100; ++i) {
- secp256k1_ge tmp;
- secp256k1_ge_set_gej(&tmp, &point);
- secp256k1_ecmult_const(&point, &tmp, &scalar);
- }
- secp256k1_ge_set_gej(&res, &point);
- ge_equals_gej(&res, &expected_point);
-}
-
-void run_ecmult_const_tests(void) {
- ecmult_const_mult_zero_one();
- ecmult_const_random_mult();
- ecmult_const_commutativity();
- ecmult_const_chain_multiply();
-}
-
-void test_wnaf(const secp256k1_scalar *number, int w) {
- secp256k1_scalar x, two, t;
- int wnaf[256];
- int zeroes = -1;
- int i;
- int bits;
- secp256k1_scalar_set_int(&x, 0);
- secp256k1_scalar_set_int(&two, 2);
- bits = secp256k1_ecmult_wnaf(wnaf, 256, number, w);
- CHECK(bits <= 256);
- for (i = bits-1; i >= 0; i--) {
- int v = wnaf[i];
- secp256k1_scalar_mul(&x, &x, &two);
- if (v) {
- CHECK(zeroes == -1 || zeroes >= w-1); /* check that distance between non-zero elements is at least w-1 */
- zeroes=0;
- CHECK((v & 1) == 1); /* check non-zero elements are odd */
- CHECK(v <= (1 << (w-1)) - 1); /* check range below */
- CHECK(v >= -(1 << (w-1)) - 1); /* check range above */
- } else {
- CHECK(zeroes != -1); /* check that no unnecessary zero padding exists */
- zeroes++;
- }
- if (v >= 0) {
- secp256k1_scalar_set_int(&t, v);
- } else {
- secp256k1_scalar_set_int(&t, -v);
- secp256k1_scalar_negate(&t, &t);
- }
- secp256k1_scalar_add(&x, &x, &t);
- }
- CHECK(secp256k1_scalar_eq(&x, number)); /* check that wnaf represents number */
-}
-
-void test_constant_wnaf_negate(const secp256k1_scalar *number) {
- secp256k1_scalar neg1 = *number;
- secp256k1_scalar neg2 = *number;
- int sign1 = 1;
- int sign2 = 1;
-
- if (!secp256k1_scalar_get_bits(&neg1, 0, 1)) {
- secp256k1_scalar_negate(&neg1, &neg1);
- sign1 = -1;
- }
- sign2 = secp256k1_scalar_cond_negate(&neg2, secp256k1_scalar_is_even(&neg2));
- CHECK(sign1 == sign2);
- CHECK(secp256k1_scalar_eq(&neg1, &neg2));
-}
-
-void test_constant_wnaf(const secp256k1_scalar *number, int w) {
- secp256k1_scalar x, shift;
- int wnaf[256] = {0};
- int i;
- int skew;
- secp256k1_scalar num = *number;
-
- secp256k1_scalar_set_int(&x, 0);
- secp256k1_scalar_set_int(&shift, 1 << w);
- /* With USE_ENDOMORPHISM on we only consider 128-bit numbers */
-#ifdef USE_ENDOMORPHISM
- for (i = 0; i < 16; ++i) {
- secp256k1_scalar_shr_int(&num, 8);
- }
-#endif
- skew = secp256k1_wnaf_const(wnaf, num, w);
-
- for (i = WNAF_SIZE(w); i >= 0; --i) {
- secp256k1_scalar t;
- int v = wnaf[i];
- CHECK(v != 0); /* check nonzero */
- CHECK(v & 1); /* check parity */
- CHECK(v > -(1 << w)); /* check range above */
- CHECK(v < (1 << w)); /* check range below */
-
- secp256k1_scalar_mul(&x, &x, &shift);
- if (v >= 0) {
- secp256k1_scalar_set_int(&t, v);
- } else {
- secp256k1_scalar_set_int(&t, -v);
- secp256k1_scalar_negate(&t, &t);
- }
- secp256k1_scalar_add(&x, &x, &t);
- }
- /* Skew num because when encoding numbers as odd we use an offset */
- secp256k1_scalar_cadd_bit(&num, skew == 2, 1);
- CHECK(secp256k1_scalar_eq(&x, &num));
-}
-
-void run_wnaf(void) {
- int i;
- secp256k1_scalar n = {{0}};
-
- /* Sanity check: 1 and 2 are the smallest odd and even numbers and should
- * have easier-to-diagnose failure modes */
- n.d[0] = 1;
- test_constant_wnaf(&n, 4);
- n.d[0] = 2;
- test_constant_wnaf(&n, 4);
- /* Random tests */
- for (i = 0; i < count; i++) {
- random_scalar_order(&n);
- test_wnaf(&n, 4+(i%10));
- test_constant_wnaf_negate(&n);
- test_constant_wnaf(&n, 4 + (i % 10));
- }
- secp256k1_scalar_set_int(&n, 0);
- CHECK(secp256k1_scalar_cond_negate(&n, 1) == -1);
- CHECK(secp256k1_scalar_is_zero(&n));
- CHECK(secp256k1_scalar_cond_negate(&n, 0) == 1);
- CHECK(secp256k1_scalar_is_zero(&n));
-}
-
-void test_ecmult_constants(void) {
- /* Test ecmult_gen() for [0..36) and [order-36..0). */
- secp256k1_scalar x;
- secp256k1_gej r;
- secp256k1_ge ng;
- int i;
- int j;
- secp256k1_ge_neg(&ng, &secp256k1_ge_const_g);
- for (i = 0; i < 36; i++ ) {
- secp256k1_scalar_set_int(&x, i);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &r, &x);
- for (j = 0; j < i; j++) {
- if (j == i - 1) {
- ge_equals_gej(&secp256k1_ge_const_g, &r);
- }
- secp256k1_gej_add_ge(&r, &r, &ng);
- }
- CHECK(secp256k1_gej_is_infinity(&r));
- }
- for (i = 1; i <= 36; i++ ) {
- secp256k1_scalar_set_int(&x, i);
- secp256k1_scalar_negate(&x, &x);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &r, &x);
- for (j = 0; j < i; j++) {
- if (j == i - 1) {
- ge_equals_gej(&ng, &r);
- }
- secp256k1_gej_add_ge(&r, &r, &secp256k1_ge_const_g);
- }
- CHECK(secp256k1_gej_is_infinity(&r));
- }
-}
-
-void run_ecmult_constants(void) {
- test_ecmult_constants();
-}
-
-void test_ecmult_gen_blind(void) {
- /* Test ecmult_gen() blinding and confirm that the blinding changes, the affine points match, and the z's don't match. */
- secp256k1_scalar key;
- secp256k1_scalar b;
- unsigned char seed32[32];
- secp256k1_gej pgej;
- secp256k1_gej pgej2;
- secp256k1_gej i;
- secp256k1_ge pge;
- random_scalar_order_test(&key);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pgej, &key);
- secp256k1_rand256(seed32);
- b = ctx->ecmult_gen_ctx.blind;
- i = ctx->ecmult_gen_ctx.initial;
- secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, seed32);
- CHECK(!secp256k1_scalar_eq(&b, &ctx->ecmult_gen_ctx.blind));
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pgej2, &key);
- CHECK(!gej_xyz_equals_gej(&pgej, &pgej2));
- CHECK(!gej_xyz_equals_gej(&i, &ctx->ecmult_gen_ctx.initial));
- secp256k1_ge_set_gej(&pge, &pgej);
- ge_equals_gej(&pge, &pgej2);
-}
-
-void test_ecmult_gen_blind_reset(void) {
- /* Test ecmult_gen() blinding reset and confirm that the blinding is consistent. */
- secp256k1_scalar b;
- secp256k1_gej initial;
- secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, 0);
- b = ctx->ecmult_gen_ctx.blind;
- initial = ctx->ecmult_gen_ctx.initial;
- secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, 0);
- CHECK(secp256k1_scalar_eq(&b, &ctx->ecmult_gen_ctx.blind));
- CHECK(gej_xyz_equals_gej(&initial, &ctx->ecmult_gen_ctx.initial));
-}
-
-void run_ecmult_gen_blind(void) {
- int i;
- test_ecmult_gen_blind_reset();
- for (i = 0; i < 10; i++) {
- test_ecmult_gen_blind();
- }
-}
-
-#ifdef USE_ENDOMORPHISM
-/***** ENDOMORPHISH TESTS *****/
-void test_scalar_split(void) {
- secp256k1_scalar full;
- secp256k1_scalar s1, slam;
- const unsigned char zero[32] = {0};
- unsigned char tmp[32];
-
- random_scalar_order_test(&full);
- secp256k1_scalar_split_lambda(&s1, &slam, &full);
-
- /* check that both are <= 128 bits in size */
- if (secp256k1_scalar_is_high(&s1)) {
- secp256k1_scalar_negate(&s1, &s1);
- }
- if (secp256k1_scalar_is_high(&slam)) {
- secp256k1_scalar_negate(&slam, &slam);
- }
-
- secp256k1_scalar_get_b32(tmp, &s1);
- CHECK(memcmp(zero, tmp, 16) == 0);
- secp256k1_scalar_get_b32(tmp, &slam);
- CHECK(memcmp(zero, tmp, 16) == 0);
-}
-
-void run_endomorphism_tests(void) {
- test_scalar_split();
-}
-#endif
-
-void ec_pubkey_parse_pointtest(const unsigned char *input, int xvalid, int yvalid) {
- unsigned char pubkeyc[65];
- secp256k1_pubkey pubkey;
- secp256k1_ge ge;
- size_t pubkeyclen;
- int32_t ecount;
- ecount = 0;
- secp256k1_context_set_illegal_callback(ctx, counting_illegal_callback_fn, &ecount);
- for (pubkeyclen = 3; pubkeyclen <= 65; pubkeyclen++) {
- /* Smaller sizes are tested exhaustively elsewhere. */
- int32_t i;
- memcpy(&pubkeyc[1], input, 64);
- VG_UNDEF(&pubkeyc[pubkeyclen], 65 - pubkeyclen);
- for (i = 0; i < 256; i++) {
- /* Try all type bytes. */
- int xpass;
- int ypass;
- int ysign;
- pubkeyc[0] = i;
- /* What sign does this point have? */
- ysign = (input[63] & 1) + 2;
- /* For the current type (i) do we expect parsing to work? Handled all of compressed/uncompressed/hybrid. */
- xpass = xvalid && (pubkeyclen == 33) && ((i & 254) == 2);
- /* Do we expect a parse and re-serialize as uncompressed to give a matching y? */
- ypass = xvalid && yvalid && ((i & 4) == ((pubkeyclen == 65) << 2)) &&
- ((i == 4) || ((i & 251) == ysign)) && ((pubkeyclen == 33) || (pubkeyclen == 65));
- if (xpass || ypass) {
- /* These cases must parse. */
- unsigned char pubkeyo[65];
- size_t outl;
- memset(&pubkey, 0, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- ecount = 0;
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, pubkeyclen) == 1);
- VG_CHECK(&pubkey, sizeof(pubkey));
- outl = 65;
- VG_UNDEF(pubkeyo, 65);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, pubkeyo, &outl, &pubkey, SECP256K1_EC_COMPRESSED) == 1);
- VG_CHECK(pubkeyo, outl);
- CHECK(outl == 33);
- CHECK(memcmp(&pubkeyo[1], &pubkeyc[1], 32) == 0);
- CHECK((pubkeyclen != 33) || (pubkeyo[0] == pubkeyc[0]));
- if (ypass) {
- /* This test isn't always done because we decode with alternative signs, so the y won't match. */
- CHECK(pubkeyo[0] == ysign);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 1);
- memset(&pubkey, 0, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- secp256k1_pubkey_save(&pubkey, &ge);
- VG_CHECK(&pubkey, sizeof(pubkey));
- outl = 65;
- VG_UNDEF(pubkeyo, 65);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, pubkeyo, &outl, &pubkey, SECP256K1_EC_UNCOMPRESSED) == 1);
- VG_CHECK(pubkeyo, outl);
- CHECK(outl == 65);
- CHECK(pubkeyo[0] == 4);
- CHECK(memcmp(&pubkeyo[1], input, 64) == 0);
- }
- CHECK(ecount == 0);
- } else {
- /* These cases must fail to parse. */
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, pubkeyclen) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- }
- }
- }
- secp256k1_context_set_illegal_callback(ctx, NULL, NULL);
-}
-
-void run_ec_pubkey_parse_test(void) {
-#define SECP256K1_EC_PARSE_TEST_NVALID (12)
- const unsigned char valid[SECP256K1_EC_PARSE_TEST_NVALID][64] = {
- {
- /* Point with leading and trailing zeros in x and y serialization. */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x52,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x64, 0xef, 0xa1, 0x7b, 0x77, 0x61, 0xe1, 0xe4, 0x27, 0x06, 0x98, 0x9f, 0xb4, 0x83,
- 0xb8, 0xd2, 0xd4, 0x9b, 0xf7, 0x8f, 0xae, 0x98, 0x03, 0xf0, 0x99, 0xb8, 0x34, 0xed, 0xeb, 0x00
- },
- {
- /* Point with x equal to a 3rd root of unity.*/
- 0x7a, 0xe9, 0x6a, 0x2b, 0x65, 0x7c, 0x07, 0x10, 0x6e, 0x64, 0x47, 0x9e, 0xac, 0x34, 0x34, 0xe9,
- 0x9c, 0xf0, 0x49, 0x75, 0x12, 0xf5, 0x89, 0x95, 0xc1, 0x39, 0x6c, 0x28, 0x71, 0x95, 0x01, 0xee,
- 0x42, 0x18, 0xf2, 0x0a, 0xe6, 0xc6, 0x46, 0xb3, 0x63, 0xdb, 0x68, 0x60, 0x58, 0x22, 0xfb, 0x14,
- 0x26, 0x4c, 0xa8, 0xd2, 0x58, 0x7f, 0xdd, 0x6f, 0xbc, 0x75, 0x0d, 0x58, 0x7e, 0x76, 0xa7, 0xee,
- },
- {
- /* Point with largest x. (1/2) */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2c,
- 0x0e, 0x99, 0x4b, 0x14, 0xea, 0x72, 0xf8, 0xc3, 0xeb, 0x95, 0xc7, 0x1e, 0xf6, 0x92, 0x57, 0x5e,
- 0x77, 0x50, 0x58, 0x33, 0x2d, 0x7e, 0x52, 0xd0, 0x99, 0x5c, 0xf8, 0x03, 0x88, 0x71, 0xb6, 0x7d,
- },
- {
- /* Point with largest x. (2/2) */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2c,
- 0xf1, 0x66, 0xb4, 0xeb, 0x15, 0x8d, 0x07, 0x3c, 0x14, 0x6a, 0x38, 0xe1, 0x09, 0x6d, 0xa8, 0xa1,
- 0x88, 0xaf, 0xa7, 0xcc, 0xd2, 0x81, 0xad, 0x2f, 0x66, 0xa3, 0x07, 0xfb, 0x77, 0x8e, 0x45, 0xb2,
- },
- {
- /* Point with smallest x. (1/2) */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x42, 0x18, 0xf2, 0x0a, 0xe6, 0xc6, 0x46, 0xb3, 0x63, 0xdb, 0x68, 0x60, 0x58, 0x22, 0xfb, 0x14,
- 0x26, 0x4c, 0xa8, 0xd2, 0x58, 0x7f, 0xdd, 0x6f, 0xbc, 0x75, 0x0d, 0x58, 0x7e, 0x76, 0xa7, 0xee,
- },
- {
- /* Point with smallest x. (2/2) */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0xbd, 0xe7, 0x0d, 0xf5, 0x19, 0x39, 0xb9, 0x4c, 0x9c, 0x24, 0x97, 0x9f, 0xa7, 0xdd, 0x04, 0xeb,
- 0xd9, 0xb3, 0x57, 0x2d, 0xa7, 0x80, 0x22, 0x90, 0x43, 0x8a, 0xf2, 0xa6, 0x81, 0x89, 0x54, 0x41,
- },
- {
- /* Point with largest y. (1/3) */
- 0x1f, 0xe1, 0xe5, 0xef, 0x3f, 0xce, 0xb5, 0xc1, 0x35, 0xab, 0x77, 0x41, 0x33, 0x3c, 0xe5, 0xa6,
- 0xe8, 0x0d, 0x68, 0x16, 0x76, 0x53, 0xf6, 0xb2, 0xb2, 0x4b, 0xcb, 0xcf, 0xaa, 0xaf, 0xf5, 0x07,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2e,
- },
- {
- /* Point with largest y. (2/3) */
- 0xcb, 0xb0, 0xde, 0xab, 0x12, 0x57, 0x54, 0xf1, 0xfd, 0xb2, 0x03, 0x8b, 0x04, 0x34, 0xed, 0x9c,
- 0xb3, 0xfb, 0x53, 0xab, 0x73, 0x53, 0x91, 0x12, 0x99, 0x94, 0xa5, 0x35, 0xd9, 0x25, 0xf6, 0x73,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2e,
- },
- {
- /* Point with largest y. (3/3) */
- 0x14, 0x6d, 0x3b, 0x65, 0xad, 0xd9, 0xf5, 0x4c, 0xcc, 0xa2, 0x85, 0x33, 0xc8, 0x8e, 0x2c, 0xbc,
- 0x63, 0xf7, 0x44, 0x3e, 0x16, 0x58, 0x78, 0x3a, 0xb4, 0x1f, 0x8e, 0xf9, 0x7c, 0x2a, 0x10, 0xb5,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2e,
- },
- {
- /* Point with smallest y. (1/3) */
- 0x1f, 0xe1, 0xe5, 0xef, 0x3f, 0xce, 0xb5, 0xc1, 0x35, 0xab, 0x77, 0x41, 0x33, 0x3c, 0xe5, 0xa6,
- 0xe8, 0x0d, 0x68, 0x16, 0x76, 0x53, 0xf6, 0xb2, 0xb2, 0x4b, 0xcb, 0xcf, 0xaa, 0xaf, 0xf5, 0x07,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- },
- {
- /* Point with smallest y. (2/3) */
- 0xcb, 0xb0, 0xde, 0xab, 0x12, 0x57, 0x54, 0xf1, 0xfd, 0xb2, 0x03, 0x8b, 0x04, 0x34, 0xed, 0x9c,
- 0xb3, 0xfb, 0x53, 0xab, 0x73, 0x53, 0x91, 0x12, 0x99, 0x94, 0xa5, 0x35, 0xd9, 0x25, 0xf6, 0x73,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- },
- {
- /* Point with smallest y. (3/3) */
- 0x14, 0x6d, 0x3b, 0x65, 0xad, 0xd9, 0xf5, 0x4c, 0xcc, 0xa2, 0x85, 0x33, 0xc8, 0x8e, 0x2c, 0xbc,
- 0x63, 0xf7, 0x44, 0x3e, 0x16, 0x58, 0x78, 0x3a, 0xb4, 0x1f, 0x8e, 0xf9, 0x7c, 0x2a, 0x10, 0xb5,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
- }
- };
-#define SECP256K1_EC_PARSE_TEST_NXVALID (4)
- const unsigned char onlyxvalid[SECP256K1_EC_PARSE_TEST_NXVALID][64] = {
- {
- /* Valid if y overflow ignored (y = 1 mod p). (1/3) */
- 0x1f, 0xe1, 0xe5, 0xef, 0x3f, 0xce, 0xb5, 0xc1, 0x35, 0xab, 0x77, 0x41, 0x33, 0x3c, 0xe5, 0xa6,
- 0xe8, 0x0d, 0x68, 0x16, 0x76, 0x53, 0xf6, 0xb2, 0xb2, 0x4b, 0xcb, 0xcf, 0xaa, 0xaf, 0xf5, 0x07,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x30,
- },
- {
- /* Valid if y overflow ignored (y = 1 mod p). (2/3) */
- 0xcb, 0xb0, 0xde, 0xab, 0x12, 0x57, 0x54, 0xf1, 0xfd, 0xb2, 0x03, 0x8b, 0x04, 0x34, 0xed, 0x9c,
- 0xb3, 0xfb, 0x53, 0xab, 0x73, 0x53, 0x91, 0x12, 0x99, 0x94, 0xa5, 0x35, 0xd9, 0x25, 0xf6, 0x73,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x30,
- },
- {
- /* Valid if y overflow ignored (y = 1 mod p). (3/3)*/
- 0x14, 0x6d, 0x3b, 0x65, 0xad, 0xd9, 0xf5, 0x4c, 0xcc, 0xa2, 0x85, 0x33, 0xc8, 0x8e, 0x2c, 0xbc,
- 0x63, 0xf7, 0x44, 0x3e, 0x16, 0x58, 0x78, 0x3a, 0xb4, 0x1f, 0x8e, 0xf9, 0x7c, 0x2a, 0x10, 0xb5,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x30,
- },
- {
- /* x on curve, y is from y^2 = x^3 + 8. */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03
- }
- };
-#define SECP256K1_EC_PARSE_TEST_NINVALID (7)
- const unsigned char invalid[SECP256K1_EC_PARSE_TEST_NINVALID][64] = {
- {
- /* x is third root of -8, y is -1 * (x^3+7); also on the curve for y^2 = x^3 + 9. */
- 0x0a, 0x2d, 0x2b, 0xa9, 0x35, 0x07, 0xf1, 0xdf, 0x23, 0x37, 0x70, 0xc2, 0xa7, 0x97, 0x96, 0x2c,
- 0xc6, 0x1f, 0x6d, 0x15, 0xda, 0x14, 0xec, 0xd4, 0x7d, 0x8d, 0x27, 0xae, 0x1c, 0xd5, 0xf8, 0x53,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- },
- {
- /* Valid if x overflow ignored (x = 1 mod p). */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x30,
- 0x42, 0x18, 0xf2, 0x0a, 0xe6, 0xc6, 0x46, 0xb3, 0x63, 0xdb, 0x68, 0x60, 0x58, 0x22, 0xfb, 0x14,
- 0x26, 0x4c, 0xa8, 0xd2, 0x58, 0x7f, 0xdd, 0x6f, 0xbc, 0x75, 0x0d, 0x58, 0x7e, 0x76, 0xa7, 0xee,
- },
- {
- /* Valid if x overflow ignored (x = 1 mod p). */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x30,
- 0xbd, 0xe7, 0x0d, 0xf5, 0x19, 0x39, 0xb9, 0x4c, 0x9c, 0x24, 0x97, 0x9f, 0xa7, 0xdd, 0x04, 0xeb,
- 0xd9, 0xb3, 0x57, 0x2d, 0xa7, 0x80, 0x22, 0x90, 0x43, 0x8a, 0xf2, 0xa6, 0x81, 0x89, 0x54, 0x41,
- },
- {
- /* x is -1, y is the result of the sqrt ladder; also on the curve for y^2 = x^3 - 5. */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2e,
- 0xf4, 0x84, 0x14, 0x5c, 0xb0, 0x14, 0x9b, 0x82, 0x5d, 0xff, 0x41, 0x2f, 0xa0, 0x52, 0xa8, 0x3f,
- 0xcb, 0x72, 0xdb, 0x61, 0xd5, 0x6f, 0x37, 0x70, 0xce, 0x06, 0x6b, 0x73, 0x49, 0xa2, 0xaa, 0x28,
- },
- {
- /* x is -1, y is the result of the sqrt ladder; also on the curve for y^2 = x^3 - 5. */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2e,
- 0x0b, 0x7b, 0xeb, 0xa3, 0x4f, 0xeb, 0x64, 0x7d, 0xa2, 0x00, 0xbe, 0xd0, 0x5f, 0xad, 0x57, 0xc0,
- 0x34, 0x8d, 0x24, 0x9e, 0x2a, 0x90, 0xc8, 0x8f, 0x31, 0xf9, 0x94, 0x8b, 0xb6, 0x5d, 0x52, 0x07,
- },
- {
- /* x is zero, y is the result of the sqrt ladder; also on the curve for y^2 = x^3 - 7. */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x8f, 0x53, 0x7e, 0xef, 0xdf, 0xc1, 0x60, 0x6a, 0x07, 0x27, 0xcd, 0x69, 0xb4, 0xa7, 0x33, 0x3d,
- 0x38, 0xed, 0x44, 0xe3, 0x93, 0x2a, 0x71, 0x79, 0xee, 0xcb, 0x4b, 0x6f, 0xba, 0x93, 0x60, 0xdc,
- },
- {
- /* x is zero, y is the result of the sqrt ladder; also on the curve for y^2 = x^3 - 7. */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x70, 0xac, 0x81, 0x10, 0x20, 0x3e, 0x9f, 0x95, 0xf8, 0xd8, 0x32, 0x96, 0x4b, 0x58, 0xcc, 0xc2,
- 0xc7, 0x12, 0xbb, 0x1c, 0x6c, 0xd5, 0x8e, 0x86, 0x11, 0x34, 0xb4, 0x8f, 0x45, 0x6c, 0x9b, 0x53
- }
- };
- const unsigned char pubkeyc[66] = {
- /* Serialization of G. */
- 0x04, 0x79, 0xBE, 0x66, 0x7E, 0xF9, 0xDC, 0xBB, 0xAC, 0x55, 0xA0, 0x62, 0x95, 0xCE, 0x87, 0x0B,
- 0x07, 0x02, 0x9B, 0xFC, 0xDB, 0x2D, 0xCE, 0x28, 0xD9, 0x59, 0xF2, 0x81, 0x5B, 0x16, 0xF8, 0x17,
- 0x98, 0x48, 0x3A, 0xDA, 0x77, 0x26, 0xA3, 0xC4, 0x65, 0x5D, 0xA4, 0xFB, 0xFC, 0x0E, 0x11, 0x08,
- 0xA8, 0xFD, 0x17, 0xB4, 0x48, 0xA6, 0x85, 0x54, 0x19, 0x9C, 0x47, 0xD0, 0x8F, 0xFB, 0x10, 0xD4,
- 0xB8, 0x00
- };
- unsigned char sout[65];
- unsigned char shortkey[2];
- secp256k1_ge ge;
- secp256k1_pubkey pubkey;
- size_t len;
- int32_t i;
- int32_t ecount;
- int32_t ecount2;
- ecount = 0;
- /* Nothing should be reading this far into pubkeyc. */
- VG_UNDEF(&pubkeyc[65], 1);
- secp256k1_context_set_illegal_callback(ctx, counting_illegal_callback_fn, &ecount);
- /* Zero length claimed, fail, zeroize, no illegal arg error. */
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(shortkey, 2);
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, shortkey, 0) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- /* Length one claimed, fail, zeroize, no illegal arg error. */
- for (i = 0; i < 256 ; i++) {
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- shortkey[0] = i;
- VG_UNDEF(&shortkey[1], 1);
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, shortkey, 1) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- }
- /* Length two claimed, fail, zeroize, no illegal arg error. */
- for (i = 0; i < 65536 ; i++) {
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- shortkey[0] = i & 255;
- shortkey[1] = i >> 8;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, shortkey, 2) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- }
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- /* 33 bytes claimed on otherwise valid input starting with 0x04, fail, zeroize output, no illegal arg error. */
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, 33) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- /* NULL pubkey, illegal arg error. Pubkey isn't rewritten before this step, since it's NULL into the parser. */
- CHECK(secp256k1_ec_pubkey_parse(ctx, NULL, pubkeyc, 65) == 0);
- CHECK(ecount == 2);
- /* NULL input string. Illegal arg and zeroize output. */
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, NULL, 65) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 1);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 2);
- /* 64 bytes claimed on input starting with 0x04, fail, zeroize output, no illegal arg error. */
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, 64) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- /* 66 bytes claimed, fail, zeroize output, no illegal arg error. */
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, 66) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- /* Valid parse. */
- memset(&pubkey, 0, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, 65) == 1);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- VG_UNDEF(&ge, sizeof(ge));
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 1);
- VG_CHECK(&ge.x, sizeof(ge.x));
- VG_CHECK(&ge.y, sizeof(ge.y));
- VG_CHECK(&ge.infinity, sizeof(ge.infinity));
- ge_equals_ge(&secp256k1_ge_const_g, &ge);
- CHECK(ecount == 0);
- /* secp256k1_ec_pubkey_serialize illegal args. */
- ecount = 0;
- len = 65;
- CHECK(secp256k1_ec_pubkey_serialize(ctx, NULL, &len, &pubkey, SECP256K1_EC_UNCOMPRESSED) == 0);
- CHECK(ecount == 1);
- CHECK(len == 0);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, sout, NULL, &pubkey, SECP256K1_EC_UNCOMPRESSED) == 0);
- CHECK(ecount == 2);
- len = 65;
- VG_UNDEF(sout, 65);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, sout, &len, NULL, SECP256K1_EC_UNCOMPRESSED) == 0);
- VG_CHECK(sout, 65);
- CHECK(ecount == 3);
- CHECK(len == 0);
- len = 65;
- CHECK(secp256k1_ec_pubkey_serialize(ctx, sout, &len, &pubkey, ~0) == 0);
- CHECK(ecount == 4);
- CHECK(len == 0);
- len = 65;
- VG_UNDEF(sout, 65);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, sout, &len, &pubkey, SECP256K1_EC_UNCOMPRESSED) == 1);
- VG_CHECK(sout, 65);
- CHECK(ecount == 4);
- CHECK(len == 65);
- /* Multiple illegal args. Should still set arg error only once. */
- ecount = 0;
- ecount2 = 11;
- CHECK(secp256k1_ec_pubkey_parse(ctx, NULL, NULL, 65) == 0);
- CHECK(ecount == 1);
- /* Does the illegal arg callback actually change the behavior? */
- secp256k1_context_set_illegal_callback(ctx, uncounting_illegal_callback_fn, &ecount2);
- CHECK(secp256k1_ec_pubkey_parse(ctx, NULL, NULL, 65) == 0);
- CHECK(ecount == 1);
- CHECK(ecount2 == 10);
- secp256k1_context_set_illegal_callback(ctx, NULL, NULL);
- /* Try a bunch of prefabbed points with all possible encodings. */
- for (i = 0; i < SECP256K1_EC_PARSE_TEST_NVALID; i++) {
- ec_pubkey_parse_pointtest(valid[i], 1, 1);
- }
- for (i = 0; i < SECP256K1_EC_PARSE_TEST_NXVALID; i++) {
- ec_pubkey_parse_pointtest(onlyxvalid[i], 1, 0);
- }
- for (i = 0; i < SECP256K1_EC_PARSE_TEST_NINVALID; i++) {
- ec_pubkey_parse_pointtest(invalid[i], 0, 0);
- }
-}
-
-void run_eckey_edge_case_test(void) {
- const unsigned char orderc[32] = {
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41
- };
- const unsigned char zeros[sizeof(secp256k1_pubkey)] = {0x00};
- unsigned char ctmp[33];
- unsigned char ctmp2[33];
- secp256k1_pubkey pubkey;
- secp256k1_pubkey pubkey2;
- secp256k1_pubkey pubkey_one;
- secp256k1_pubkey pubkey_negone;
- const secp256k1_pubkey *pubkeys[3];
- size_t len;
- int32_t ecount;
- /* Group order is too large, reject. */
- CHECK(secp256k1_ec_seckey_verify(ctx, orderc) == 0);
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, orderc) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- /* Maximum value is too large, reject. */
- memset(ctmp, 255, 32);
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 0);
- memset(&pubkey, 1, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, ctmp) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- /* Zero is too small, reject. */
- memset(ctmp, 0, 32);
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 0);
- memset(&pubkey, 1, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, ctmp) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- /* One must be accepted. */
- ctmp[31] = 0x01;
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 1);
- memset(&pubkey, 0, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, ctmp) == 1);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) > 0);
- pubkey_one = pubkey;
- /* Group order + 1 is too large, reject. */
- memcpy(ctmp, orderc, 32);
- ctmp[31] = 0x42;
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 0);
- memset(&pubkey, 1, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, ctmp) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- /* -1 must be accepted. */
- ctmp[31] = 0x40;
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 1);
- memset(&pubkey, 0, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, ctmp) == 1);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) > 0);
- pubkey_negone = pubkey;
- /* Tweak of zero leaves the value changed. */
- memset(ctmp2, 0, 32);
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, ctmp, ctmp2) == 1);
- CHECK(memcmp(orderc, ctmp, 31) == 0 && ctmp[31] == 0x40);
- memcpy(&pubkey2, &pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, ctmp2) == 1);
- CHECK(memcmp(&pubkey, &pubkey2, sizeof(pubkey)) == 0);
- /* Multiply tweak of zero zeroizes the output. */
- CHECK(secp256k1_ec_privkey_tweak_mul(ctx, ctmp, ctmp2) == 0);
- CHECK(memcmp(zeros, ctmp, 32) == 0);
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey, ctmp2) == 0);
- CHECK(memcmp(&pubkey, zeros, sizeof(pubkey)) == 0);
- memcpy(&pubkey, &pubkey2, sizeof(pubkey));
- /* Overflowing key tweak zeroizes. */
- memcpy(ctmp, orderc, 32);
- ctmp[31] = 0x40;
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, ctmp, orderc) == 0);
- CHECK(memcmp(zeros, ctmp, 32) == 0);
- memcpy(ctmp, orderc, 32);
- ctmp[31] = 0x40;
- CHECK(secp256k1_ec_privkey_tweak_mul(ctx, ctmp, orderc) == 0);
- CHECK(memcmp(zeros, ctmp, 32) == 0);
- memcpy(ctmp, orderc, 32);
- ctmp[31] = 0x40;
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, orderc) == 0);
- CHECK(memcmp(&pubkey, zeros, sizeof(pubkey)) == 0);
- memcpy(&pubkey, &pubkey2, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey, orderc) == 0);
- CHECK(memcmp(&pubkey, zeros, sizeof(pubkey)) == 0);
- memcpy(&pubkey, &pubkey2, sizeof(pubkey));
- /* Private key tweaks results in a key of zero. */
- ctmp2[31] = 1;
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, ctmp2, ctmp) == 0);
- CHECK(memcmp(zeros, ctmp2, 32) == 0);
- ctmp2[31] = 1;
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, ctmp2) == 0);
- CHECK(memcmp(&pubkey, zeros, sizeof(pubkey)) == 0);
- memcpy(&pubkey, &pubkey2, sizeof(pubkey));
- /* Tweak computation wraps and results in a key of 1. */
- ctmp2[31] = 2;
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, ctmp2, ctmp) == 1);
- CHECK(memcmp(ctmp2, zeros, 31) == 0 && ctmp2[31] == 1);
- ctmp2[31] = 2;
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, ctmp2) == 1);
- ctmp2[31] = 1;
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey2, ctmp2) == 1);
- CHECK(memcmp(&pubkey, &pubkey2, sizeof(pubkey)) == 0);
- /* Tweak mul * 2 = 1+1. */
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, ctmp2) == 1);
- ctmp2[31] = 2;
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey2, ctmp2) == 1);
- CHECK(memcmp(&pubkey, &pubkey2, sizeof(pubkey)) == 0);
- /* Test argument errors. */
- ecount = 0;
- secp256k1_context_set_illegal_callback(ctx, counting_illegal_callback_fn, &ecount);
- CHECK(ecount == 0);
- /* Zeroize pubkey on parse error. */
- memset(&pubkey, 0, 32);
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, ctmp2) == 0);
- CHECK(ecount == 1);
- CHECK(memcmp(&pubkey, zeros, sizeof(pubkey)) == 0);
- memcpy(&pubkey, &pubkey2, sizeof(pubkey));
- memset(&pubkey2, 0, 32);
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey2, ctmp2) == 0);
- CHECK(ecount == 2);
- CHECK(memcmp(&pubkey2, zeros, sizeof(pubkey2)) == 0);
- /* Plain argument errors. */
- ecount = 0;
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 1);
- CHECK(ecount == 0);
- CHECK(secp256k1_ec_seckey_verify(ctx, NULL) == 0);
- CHECK(ecount == 1);
- ecount = 0;
- memset(ctmp2, 0, 32);
- ctmp2[31] = 4;
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, NULL, ctmp2) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, NULL) == 0);
- CHECK(ecount == 2);
- ecount = 0;
- memset(ctmp2, 0, 32);
- ctmp2[31] = 4;
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, NULL, ctmp2) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey, NULL) == 0);
- CHECK(ecount == 2);
- ecount = 0;
- memset(ctmp2, 0, 32);
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, NULL, ctmp2) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, ctmp, NULL) == 0);
- CHECK(ecount == 2);
- ecount = 0;
- memset(ctmp2, 0, 32);
- ctmp2[31] = 1;
- CHECK(secp256k1_ec_privkey_tweak_mul(ctx, NULL, ctmp2) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ec_privkey_tweak_mul(ctx, ctmp, NULL) == 0);
- CHECK(ecount == 2);
- ecount = 0;
- CHECK(secp256k1_ec_pubkey_create(ctx, NULL, ctmp) == 0);
- CHECK(ecount == 1);
- memset(&pubkey, 1, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, NULL) == 0);
- CHECK(ecount == 2);
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- /* secp256k1_ec_pubkey_combine tests. */
- ecount = 0;
- pubkeys[0] = &pubkey_one;
- VG_UNDEF(&pubkeys[0], sizeof(secp256k1_pubkey *));
- VG_UNDEF(&pubkeys[1], sizeof(secp256k1_pubkey *));
- VG_UNDEF(&pubkeys[2], sizeof(secp256k1_pubkey *));
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, pubkeys, 0) == 0);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ec_pubkey_combine(ctx, NULL, pubkeys, 1) == 0);
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- CHECK(ecount == 2);
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, NULL, 1) == 0);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- CHECK(ecount == 3);
- pubkeys[0] = &pubkey_negone;
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, pubkeys, 1) == 1);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) > 0);
- CHECK(ecount == 3);
- len = 33;
- CHECK(secp256k1_ec_pubkey_serialize(ctx, ctmp, &len, &pubkey, SECP256K1_EC_COMPRESSED) == 1);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, ctmp2, &len, &pubkey_negone, SECP256K1_EC_COMPRESSED) == 1);
- CHECK(memcmp(ctmp, ctmp2, 33) == 0);
- /* Result is infinity. */
- pubkeys[0] = &pubkey_one;
- pubkeys[1] = &pubkey_negone;
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, pubkeys, 2) == 0);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- CHECK(ecount == 3);
- /* Passes through infinity but comes out one. */
- pubkeys[2] = &pubkey_one;
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, pubkeys, 3) == 1);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) > 0);
- CHECK(ecount == 3);
- len = 33;
- CHECK(secp256k1_ec_pubkey_serialize(ctx, ctmp, &len, &pubkey, SECP256K1_EC_COMPRESSED) == 1);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, ctmp2, &len, &pubkey_one, SECP256K1_EC_COMPRESSED) == 1);
- CHECK(memcmp(ctmp, ctmp2, 33) == 0);
- /* Adds to two. */
- pubkeys[1] = &pubkey_one;
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, pubkeys, 2) == 1);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) > 0);
- CHECK(ecount == 3);
- secp256k1_context_set_illegal_callback(ctx, NULL, NULL);
-}
-
-void random_sign(secp256k1_scalar *sigr, secp256k1_scalar *sigs, const secp256k1_scalar *key, const secp256k1_scalar *msg, int *recid) {
- secp256k1_scalar nonce;
- do {
- random_scalar_order_test(&nonce);
- } while(!secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, sigr, sigs, key, msg, &nonce, recid));
-}
-
-void test_ecdsa_sign_verify(void) {
- secp256k1_gej pubj;
- secp256k1_ge pub;
- secp256k1_scalar one;
- secp256k1_scalar msg, key;
- secp256k1_scalar sigr, sigs;
- int recid;
- int getrec;
- random_scalar_order_test(&msg);
- random_scalar_order_test(&key);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pubj, &key);
- secp256k1_ge_set_gej(&pub, &pubj);
- getrec = secp256k1_rand_bits(1);
- random_sign(&sigr, &sigs, &key, &msg, getrec?&recid:NULL);
- if (getrec) {
- CHECK(recid >= 0 && recid < 4);
- }
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sigr, &sigs, &pub, &msg));
- secp256k1_scalar_set_int(&one, 1);
- secp256k1_scalar_add(&msg, &msg, &one);
- CHECK(!secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sigr, &sigs, &pub, &msg));
-}
-
-void run_ecdsa_sign_verify(void) {
- int i;
- for (i = 0; i < 10*count; i++) {
- test_ecdsa_sign_verify();
- }
-}
-
-/** Dummy nonce generation function that just uses a precomputed nonce, and fails if it is not accepted. Use only for testing. */
-static int precomputed_nonce_function(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
- (void)msg32;
- (void)key32;
- (void)algo16;
- memcpy(nonce32, data, 32);
- return (counter == 0);
-}
-
-static int nonce_function_test_fail(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
- /* Dummy nonce generator that has a fatal error on the first counter value. */
- if (counter == 0) {
- return 0;
- }
- return nonce_function_rfc6979(nonce32, msg32, key32, algo16, data, counter - 1);
-}
-
-static int nonce_function_test_retry(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
- /* Dummy nonce generator that produces unacceptable nonces for the first several counter values. */
- if (counter < 3) {
- memset(nonce32, counter==0 ? 0 : 255, 32);
- if (counter == 2) {
- nonce32[31]--;
- }
- return 1;
- }
- if (counter < 5) {
- static const unsigned char order[] = {
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
- 0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,
- 0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x41
- };
- memcpy(nonce32, order, 32);
- if (counter == 4) {
- nonce32[31]++;
- }
- return 1;
- }
- /* Retry rate of 6979 is negligible esp. as we only call this in deterministic tests. */
- /* If someone does fine a case where it retries for secp256k1, we'd like to know. */
- if (counter > 5) {
- return 0;
- }
- return nonce_function_rfc6979(nonce32, msg32, key32, algo16, data, counter - 5);
-}
-
-int is_empty_signature(const secp256k1_ecdsa_signature *sig) {
- static const unsigned char res[sizeof(secp256k1_ecdsa_signature)] = {0};
- return memcmp(sig, res, sizeof(secp256k1_ecdsa_signature)) == 0;
-}
-
-void test_ecdsa_end_to_end(void) {
- unsigned char extra[32] = {0x00};
- unsigned char privkey[32];
- unsigned char message[32];
- unsigned char privkey2[32];
- secp256k1_ecdsa_signature signature[6];
- secp256k1_scalar r, s;
- unsigned char sig[74];
- size_t siglen = 74;
- unsigned char pubkeyc[65];
- size_t pubkeyclen = 65;
- secp256k1_pubkey pubkey;
- unsigned char seckey[300];
- size_t seckeylen = 300;
-
- /* Generate a random key and message. */
- {
- secp256k1_scalar msg, key;
- random_scalar_order_test(&msg);
- random_scalar_order_test(&key);
- secp256k1_scalar_get_b32(privkey, &key);
- secp256k1_scalar_get_b32(message, &msg);
- }
-
- /* Construct and verify corresponding public key. */
- CHECK(secp256k1_ec_seckey_verify(ctx, privkey) == 1);
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, privkey) == 1);
-
- /* Verify exporting and importing public key. */
- CHECK(secp256k1_ec_pubkey_serialize(ctx, pubkeyc, &pubkeyclen, &pubkey, secp256k1_rand_bits(1) == 1 ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED));
- memset(&pubkey, 0, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, pubkeyclen) == 1);
-
- /* Verify private key import and export. */
- CHECK(ec_privkey_export_der(ctx, seckey, &seckeylen, privkey, secp256k1_rand_bits(1) == 1));
- CHECK(ec_privkey_import_der(ctx, privkey2, seckey, seckeylen) == 1);
- CHECK(memcmp(privkey, privkey2, 32) == 0);
-
- /* Optionally tweak the keys using addition. */
- if (secp256k1_rand_int(3) == 0) {
- int ret1;
- int ret2;
- unsigned char rnd[32];
- secp256k1_pubkey pubkey2;
- secp256k1_rand256_test(rnd);
- ret1 = secp256k1_ec_privkey_tweak_add(ctx, privkey, rnd);
- ret2 = secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, rnd);
- CHECK(ret1 == ret2);
- if (ret1 == 0) {
- return;
- }
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey2, privkey) == 1);
- CHECK(memcmp(&pubkey, &pubkey2, sizeof(pubkey)) == 0);
- }
-
- /* Optionally tweak the keys using multiplication. */
- if (secp256k1_rand_int(3) == 0) {
- int ret1;
- int ret2;
- unsigned char rnd[32];
- secp256k1_pubkey pubkey2;
- secp256k1_rand256_test(rnd);
- ret1 = secp256k1_ec_privkey_tweak_mul(ctx, privkey, rnd);
- ret2 = secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey, rnd);
- CHECK(ret1 == ret2);
- if (ret1 == 0) {
- return;
- }
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey2, privkey) == 1);
- CHECK(memcmp(&pubkey, &pubkey2, sizeof(pubkey)) == 0);
- }
-
- /* Sign. */
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[0], message, privkey, NULL, NULL) == 1);
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[4], message, privkey, NULL, NULL) == 1);
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[1], message, privkey, NULL, extra) == 1);
- extra[31] = 1;
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[2], message, privkey, NULL, extra) == 1);
- extra[31] = 0;
- extra[0] = 1;
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[3], message, privkey, NULL, extra) == 1);
- CHECK(memcmp(&signature[0], &signature[4], sizeof(signature[0])) == 0);
- CHECK(memcmp(&signature[0], &signature[1], sizeof(signature[0])) != 0);
- CHECK(memcmp(&signature[0], &signature[2], sizeof(signature[0])) != 0);
- CHECK(memcmp(&signature[0], &signature[3], sizeof(signature[0])) != 0);
- CHECK(memcmp(&signature[1], &signature[2], sizeof(signature[0])) != 0);
- CHECK(memcmp(&signature[1], &signature[3], sizeof(signature[0])) != 0);
- CHECK(memcmp(&signature[2], &signature[3], sizeof(signature[0])) != 0);
- /* Verify. */
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[0], message, &pubkey) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[1], message, &pubkey) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[2], message, &pubkey) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[3], message, &pubkey) == 1);
- /* Test lower-S form, malleate, verify and fail, test again, malleate again */
- CHECK(!secp256k1_ecdsa_signature_normalize(ctx, NULL, &signature[0]));
- secp256k1_ecdsa_signature_load(ctx, &r, &s, &signature[0]);
- secp256k1_scalar_negate(&s, &s);
- secp256k1_ecdsa_signature_save(&signature[5], &r, &s);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[5], message, &pubkey) == 0);
- CHECK(secp256k1_ecdsa_signature_normalize(ctx, NULL, &signature[5]));
- CHECK(secp256k1_ecdsa_signature_normalize(ctx, &signature[5], &signature[5]));
- CHECK(!secp256k1_ecdsa_signature_normalize(ctx, NULL, &signature[5]));
- CHECK(!secp256k1_ecdsa_signature_normalize(ctx, &signature[5], &signature[5]));
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[5], message, &pubkey) == 1);
- secp256k1_scalar_negate(&s, &s);
- secp256k1_ecdsa_signature_save(&signature[5], &r, &s);
- CHECK(!secp256k1_ecdsa_signature_normalize(ctx, NULL, &signature[5]));
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[5], message, &pubkey) == 1);
- CHECK(memcmp(&signature[5], &signature[0], 64) == 0);
-
- /* Serialize/parse DER and verify again */
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, sig, &siglen, &signature[0]) == 1);
- memset(&signature[0], 0, sizeof(signature[0]));
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &signature[0], sig, siglen) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[0], message, &pubkey) == 1);
- /* Serialize/destroy/parse DER and verify again. */
- siglen = 74;
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, sig, &siglen, &signature[0]) == 1);
- sig[secp256k1_rand_int(siglen)] += 1 + secp256k1_rand_int(255);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &signature[0], sig, siglen) == 0 ||
- secp256k1_ecdsa_verify(ctx, &signature[0], message, &pubkey) == 0);
-}
-
-void test_random_pubkeys(void) {
- secp256k1_ge elem;
- secp256k1_ge elem2;
- unsigned char in[65];
- /* Generate some randomly sized pubkeys. */
- size_t len = secp256k1_rand_bits(2) == 0 ? 65 : 33;
- if (secp256k1_rand_bits(2) == 0) {
- len = secp256k1_rand_bits(6);
- }
- if (len == 65) {
- in[0] = secp256k1_rand_bits(1) ? 4 : (secp256k1_rand_bits(1) ? 6 : 7);
- } else {
- in[0] = secp256k1_rand_bits(1) ? 2 : 3;
- }
- if (secp256k1_rand_bits(3) == 0) {
- in[0] = secp256k1_rand_bits(8);
- }
- if (len > 1) {
- secp256k1_rand256(&in[1]);
- }
- if (len > 33) {
- secp256k1_rand256(&in[33]);
- }
- if (secp256k1_eckey_pubkey_parse(&elem, in, len)) {
- unsigned char out[65];
- unsigned char firstb;
- int res;
- size_t size = len;
- firstb = in[0];
- /* If the pubkey can be parsed, it should round-trip... */
- CHECK(secp256k1_eckey_pubkey_serialize(&elem, out, &size, len == 33));
- CHECK(size == len);
- CHECK(memcmp(&in[1], &out[1], len-1) == 0);
- /* ... except for the type of hybrid inputs. */
- if ((in[0] != 6) && (in[0] != 7)) {
- CHECK(in[0] == out[0]);
- }
- size = 65;
- CHECK(secp256k1_eckey_pubkey_serialize(&elem, in, &size, 0));
- CHECK(size == 65);
- CHECK(secp256k1_eckey_pubkey_parse(&elem2, in, size));
- ge_equals_ge(&elem,&elem2);
- /* Check that the X9.62 hybrid type is checked. */
- in[0] = secp256k1_rand_bits(1) ? 6 : 7;
- res = secp256k1_eckey_pubkey_parse(&elem2, in, size);
- if (firstb == 2 || firstb == 3) {
- if (in[0] == firstb + 4) {
- CHECK(res);
- } else {
- CHECK(!res);
- }
- }
- if (res) {
- ge_equals_ge(&elem,&elem2);
- CHECK(secp256k1_eckey_pubkey_serialize(&elem, out, &size, 0));
- CHECK(memcmp(&in[1], &out[1], 64) == 0);
- }
- }
-}
-
-void run_random_pubkeys(void) {
- int i;
- for (i = 0; i < 10*count; i++) {
- test_random_pubkeys();
- }
-}
-
-void run_ecdsa_end_to_end(void) {
- int i;
- for (i = 0; i < 64*count; i++) {
- test_ecdsa_end_to_end();
- }
-}
-
-int test_ecdsa_der_parse(const unsigned char *sig, size_t siglen, int certainly_der, int certainly_not_der) {
- static const unsigned char zeroes[32] = {0};
-#ifdef ENABLE_OPENSSL_TESTS
- static const unsigned char max_scalar[32] = {
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x40
- };
-#endif
-
- int ret = 0;
-
- secp256k1_ecdsa_signature sig_der;
- unsigned char roundtrip_der[2048];
- unsigned char compact_der[64];
- size_t len_der = 2048;
- int parsed_der = 0, valid_der = 0, roundtrips_der = 0;
-
- secp256k1_ecdsa_signature sig_der_lax;
- unsigned char roundtrip_der_lax[2048];
- unsigned char compact_der_lax[64];
- size_t len_der_lax = 2048;
- int parsed_der_lax = 0, valid_der_lax = 0, roundtrips_der_lax = 0;
-
-#ifdef ENABLE_OPENSSL_TESTS
- ECDSA_SIG *sig_openssl;
- const unsigned char *sigptr;
- unsigned char roundtrip_openssl[2048];
- int len_openssl = 2048;
- int parsed_openssl, valid_openssl = 0, roundtrips_openssl = 0;
-#endif
-
- parsed_der = secp256k1_ecdsa_signature_parse_der(ctx, &sig_der, sig, siglen);
- if (parsed_der) {
- ret |= (!secp256k1_ecdsa_signature_serialize_compact(ctx, compact_der, &sig_der)) << 0;
- valid_der = (memcmp(compact_der, zeroes, 32) != 0) && (memcmp(compact_der + 32, zeroes, 32) != 0);
- }
- if (valid_der) {
- ret |= (!secp256k1_ecdsa_signature_serialize_der(ctx, roundtrip_der, &len_der, &sig_der)) << 1;
- roundtrips_der = (len_der == siglen) && memcmp(roundtrip_der, sig, siglen) == 0;
- }
-
- parsed_der_lax = ecdsa_signature_parse_der_lax(ctx, &sig_der_lax, sig, siglen);
- if (parsed_der_lax) {
- ret |= (!secp256k1_ecdsa_signature_serialize_compact(ctx, compact_der_lax, &sig_der_lax)) << 10;
- valid_der_lax = (memcmp(compact_der_lax, zeroes, 32) != 0) && (memcmp(compact_der_lax + 32, zeroes, 32) != 0);
- }
- if (valid_der_lax) {
- ret |= (!secp256k1_ecdsa_signature_serialize_der(ctx, roundtrip_der_lax, &len_der_lax, &sig_der_lax)) << 11;
- roundtrips_der_lax = (len_der_lax == siglen) && memcmp(roundtrip_der_lax, sig, siglen) == 0;
- }
-
- if (certainly_der) {
- ret |= (!parsed_der) << 2;
- }
- if (certainly_not_der) {
- ret |= (parsed_der) << 17;
- }
- if (valid_der) {
- ret |= (!roundtrips_der) << 3;
- }
-
- if (valid_der) {
- ret |= (!roundtrips_der_lax) << 12;
- ret |= (len_der != len_der_lax) << 13;
- ret |= (memcmp(roundtrip_der_lax, roundtrip_der, len_der) != 0) << 14;
- }
- ret |= (roundtrips_der != roundtrips_der_lax) << 15;
- if (parsed_der) {
- ret |= (!parsed_der_lax) << 16;
- }
-
-#ifdef ENABLE_OPENSSL_TESTS
- sig_openssl = ECDSA_SIG_new();
- sigptr = sig;
- parsed_openssl = (d2i_ECDSA_SIG(&sig_openssl, &sigptr, siglen) != NULL);
- if (parsed_openssl) {
- valid_openssl = !BN_is_negative(sig_openssl->r) && !BN_is_negative(sig_openssl->s) && BN_num_bits(sig_openssl->r) > 0 && BN_num_bits(sig_openssl->r) <= 256 && BN_num_bits(sig_openssl->s) > 0 && BN_num_bits(sig_openssl->s) <= 256;
- if (valid_openssl) {
- unsigned char tmp[32] = {0};
- BN_bn2bin(sig_openssl->r, tmp + 32 - BN_num_bytes(sig_openssl->r));
- valid_openssl = memcmp(tmp, max_scalar, 32) < 0;
- }
- if (valid_openssl) {
- unsigned char tmp[32] = {0};
- BN_bn2bin(sig_openssl->s, tmp + 32 - BN_num_bytes(sig_openssl->s));
- valid_openssl = memcmp(tmp, max_scalar, 32) < 0;
- }
- }
- len_openssl = i2d_ECDSA_SIG(sig_openssl, NULL);
- if (len_openssl <= 2048) {
- unsigned char *ptr = roundtrip_openssl;
- CHECK(i2d_ECDSA_SIG(sig_openssl, &ptr) == len_openssl);
- roundtrips_openssl = valid_openssl && ((size_t)len_openssl == siglen) && (memcmp(roundtrip_openssl, sig, siglen) == 0);
- } else {
- len_openssl = 0;
- }
- ECDSA_SIG_free(sig_openssl);
-
- ret |= (parsed_der && !parsed_openssl) << 4;
- ret |= (valid_der && !valid_openssl) << 5;
- ret |= (roundtrips_openssl && !parsed_der) << 6;
- ret |= (roundtrips_der != roundtrips_openssl) << 7;
- if (roundtrips_openssl) {
- ret |= (len_der != (size_t)len_openssl) << 8;
- ret |= (memcmp(roundtrip_der, roundtrip_openssl, len_der) != 0) << 9;
- }
-#endif
- return ret;
-}
-
-static void assign_big_endian(unsigned char *ptr, size_t ptrlen, uint32_t val) {
- size_t i;
- for (i = 0; i < ptrlen; i++) {
- int shift = ptrlen - 1 - i;
- if (shift >= 4) {
- ptr[i] = 0;
- } else {
- ptr[i] = (val >> shift) & 0xFF;
- }
- }
-}
-
-static void damage_array(unsigned char *sig, size_t *len) {
- int pos;
- int action = secp256k1_rand_bits(3);
- if (action < 1 && *len > 3) {
- /* Delete a byte. */
- pos = secp256k1_rand_int(*len);
- memmove(sig + pos, sig + pos + 1, *len - pos - 1);
- (*len)--;
- return;
- } else if (action < 2 && *len < 2048) {
- /* Insert a byte. */
- pos = secp256k1_rand_int(1 + *len);
- memmove(sig + pos + 1, sig + pos, *len - pos);
- sig[pos] = secp256k1_rand_bits(8);
- (*len)++;
- return;
- } else if (action < 4) {
- /* Modify a byte. */
- sig[secp256k1_rand_int(*len)] += 1 + secp256k1_rand_int(255);
- return;
- } else { /* action < 8 */
- /* Modify a bit. */
- sig[secp256k1_rand_int(*len)] ^= 1 << secp256k1_rand_bits(3);
- return;
- }
-}
-
-static void random_ber_signature(unsigned char *sig, size_t *len, int* certainly_der, int* certainly_not_der) {
- int der;
- int nlow[2], nlen[2], nlenlen[2], nhbit[2], nhbyte[2], nzlen[2];
- size_t tlen, elen, glen;
- int indet;
- int n;
-
- *len = 0;
- der = secp256k1_rand_bits(2) == 0;
- *certainly_der = der;
- *certainly_not_der = 0;
- indet = der ? 0 : secp256k1_rand_int(10) == 0;
-
- for (n = 0; n < 2; n++) {
- /* We generate two classes of numbers: nlow==1 "low" ones (up to 32 bytes), nlow==0 "high" ones (32 bytes with 129 top bits set, or larger than 32 bytes) */
- nlow[n] = der ? 1 : (secp256k1_rand_bits(3) != 0);
- /* The length of the number in bytes (the first byte of which will always be nonzero) */
- nlen[n] = nlow[n] ? secp256k1_rand_int(33) : 32 + secp256k1_rand_int(200) * secp256k1_rand_int(8) / 8;
- CHECK(nlen[n] <= 232);
- /* The top bit of the number. */
- nhbit[n] = (nlow[n] == 0 && nlen[n] == 32) ? 1 : (nlen[n] == 0 ? 0 : secp256k1_rand_bits(1));
- /* The top byte of the number (after the potential hardcoded 16 0xFF characters for "high" 32 bytes numbers) */
- nhbyte[n] = nlen[n] == 0 ? 0 : (nhbit[n] ? 128 + secp256k1_rand_bits(7) : 1 + secp256k1_rand_int(127));
- /* The number of zero bytes in front of the number (which is 0 or 1 in case of DER, otherwise we extend up to 300 bytes) */
- nzlen[n] = der ? ((nlen[n] == 0 || nhbit[n]) ? 1 : 0) : (nlow[n] ? secp256k1_rand_int(3) : secp256k1_rand_int(300 - nlen[n]) * secp256k1_rand_int(8) / 8);
- if (nzlen[n] > ((nlen[n] == 0 || nhbit[n]) ? 1 : 0)) {
- *certainly_not_der = 1;
- }
- CHECK(nlen[n] + nzlen[n] <= 300);
- /* The length of the length descriptor for the number. 0 means short encoding, anything else is long encoding. */
- nlenlen[n] = nlen[n] + nzlen[n] < 128 ? 0 : (nlen[n] + nzlen[n] < 256 ? 1 : 2);
- if (!der) {
- /* nlenlen[n] max 127 bytes */
- int add = secp256k1_rand_int(127 - nlenlen[n]) * secp256k1_rand_int(16) * secp256k1_rand_int(16) / 256;
- nlenlen[n] += add;
- if (add != 0) {
- *certainly_not_der = 1;
- }
- }
- CHECK(nlen[n] + nzlen[n] + nlenlen[n] <= 427);
- }
-
- /* The total length of the data to go, so far */
- tlen = 2 + nlenlen[0] + nlen[0] + nzlen[0] + 2 + nlenlen[1] + nlen[1] + nzlen[1];
- CHECK(tlen <= 856);
-
- /* The length of the garbage inside the tuple. */
- elen = (der || indet) ? 0 : secp256k1_rand_int(980 - tlen) * secp256k1_rand_int(8) / 8;
- if (elen != 0) {
- *certainly_not_der = 1;
- }
- tlen += elen;
- CHECK(tlen <= 980);
-
- /* The length of the garbage after the end of the tuple. */
- glen = der ? 0 : secp256k1_rand_int(990 - tlen) * secp256k1_rand_int(8) / 8;
- if (glen != 0) {
- *certainly_not_der = 1;
- }
- CHECK(tlen + glen <= 990);
-
- /* Write the tuple header. */
- sig[(*len)++] = 0x30;
- if (indet) {
- /* Indeterminate length */
- sig[(*len)++] = 0x80;
- *certainly_not_der = 1;
- } else {
- int tlenlen = tlen < 128 ? 0 : (tlen < 256 ? 1 : 2);
- if (!der) {
- int add = secp256k1_rand_int(127 - tlenlen) * secp256k1_rand_int(16) * secp256k1_rand_int(16) / 256;
- tlenlen += add;
- if (add != 0) {
- *certainly_not_der = 1;
- }
- }
- if (tlenlen == 0) {
- /* Short length notation */
- sig[(*len)++] = tlen;
- } else {
- /* Long length notation */
- sig[(*len)++] = 128 + tlenlen;
- assign_big_endian(sig + *len, tlenlen, tlen);
- *len += tlenlen;
- }
- tlen += tlenlen;
- }
- tlen += 2;
- CHECK(tlen + glen <= 1119);
-
- for (n = 0; n < 2; n++) {
- /* Write the integer header. */
- sig[(*len)++] = 0x02;
- if (nlenlen[n] == 0) {
- /* Short length notation */
- sig[(*len)++] = nlen[n] + nzlen[n];
- } else {
- /* Long length notation. */
- sig[(*len)++] = 128 + nlenlen[n];
- assign_big_endian(sig + *len, nlenlen[n], nlen[n] + nzlen[n]);
- *len += nlenlen[n];
- }
- /* Write zero padding */
- while (nzlen[n] > 0) {
- sig[(*len)++] = 0x00;
- nzlen[n]--;
- }
- if (nlen[n] == 32 && !nlow[n]) {
- /* Special extra 16 0xFF bytes in "high" 32-byte numbers */
- int i;
- for (i = 0; i < 16; i++) {
- sig[(*len)++] = 0xFF;
- }
- nlen[n] -= 16;
- }
- /* Write first byte of number */
- if (nlen[n] > 0) {
- sig[(*len)++] = nhbyte[n];
- nlen[n]--;
- }
- /* Generate remaining random bytes of number */
- secp256k1_rand_bytes_test(sig + *len, nlen[n]);
- *len += nlen[n];
- nlen[n] = 0;
- }
-
- /* Generate random garbage inside tuple. */
- secp256k1_rand_bytes_test(sig + *len, elen);
- *len += elen;
-
- /* Generate end-of-contents bytes. */
- if (indet) {
- sig[(*len)++] = 0;
- sig[(*len)++] = 0;
- tlen += 2;
- }
- CHECK(tlen + glen <= 1121);
-
- /* Generate random garbage outside tuple. */
- secp256k1_rand_bytes_test(sig + *len, glen);
- *len += glen;
- tlen += glen;
- CHECK(tlen <= 1121);
- CHECK(tlen == *len);
-}
-
-void run_ecdsa_der_parse(void) {
- int i,j;
- for (i = 0; i < 200 * count; i++) {
- unsigned char buffer[2048];
- size_t buflen = 0;
- int certainly_der = 0;
- int certainly_not_der = 0;
- random_ber_signature(buffer, &buflen, &certainly_der, &certainly_not_der);
- CHECK(buflen <= 2048);
- for (j = 0; j < 16; j++) {
- int ret = 0;
- if (j > 0) {
- damage_array(buffer, &buflen);
- /* We don't know anything anymore about the DERness of the result */
- certainly_der = 0;
- certainly_not_der = 0;
- }
- ret = test_ecdsa_der_parse(buffer, buflen, certainly_der, certainly_not_der);
- if (ret != 0) {
- size_t k;
- fprintf(stderr, "Failure %x on ", ret);
- for (k = 0; k < buflen; k++) {
- fprintf(stderr, "%02x ", buffer[k]);
- }
- fprintf(stderr, "\n");
- }
- CHECK(ret == 0);
- }
- }
-}
-
-/* Tests several edge cases. */
-void test_ecdsa_edge_cases(void) {
- int t;
- secp256k1_ecdsa_signature sig;
-
- /* Test the case where ECDSA recomputes a point that is infinity. */
- {
- secp256k1_gej keyj;
- secp256k1_ge key;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 1);
- secp256k1_scalar_negate(&ss, &ss);
- secp256k1_scalar_inverse(&ss, &ss);
- secp256k1_scalar_set_int(&sr, 1);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &keyj, &sr);
- secp256k1_ge_set_gej(&key, &keyj);
- msg = ss;
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- }
-
- /* Verify signature with r of zero fails. */
- {
- const unsigned char pubkey_mods_zero[33] = {
- 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xfe, 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0,
- 0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41,
- 0x41
- };
- secp256k1_ge key;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 1);
- secp256k1_scalar_set_int(&msg, 0);
- secp256k1_scalar_set_int(&sr, 0);
- CHECK(secp256k1_eckey_pubkey_parse(&key, pubkey_mods_zero, 33));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- }
-
- /* Verify signature with s of zero fails. */
- {
- const unsigned char pubkey[33] = {
- 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x01
- };
- secp256k1_ge key;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 0);
- secp256k1_scalar_set_int(&msg, 0);
- secp256k1_scalar_set_int(&sr, 1);
- CHECK(secp256k1_eckey_pubkey_parse(&key, pubkey, 33));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- }
-
- /* Verify signature with message 0 passes. */
- {
- const unsigned char pubkey[33] = {
- 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x02
- };
- const unsigned char pubkey2[33] = {
- 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xfe, 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0,
- 0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41,
- 0x43
- };
- secp256k1_ge key;
- secp256k1_ge key2;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 2);
- secp256k1_scalar_set_int(&msg, 0);
- secp256k1_scalar_set_int(&sr, 2);
- CHECK(secp256k1_eckey_pubkey_parse(&key, pubkey, 33));
- CHECK(secp256k1_eckey_pubkey_parse(&key2, pubkey2, 33));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 1);
- secp256k1_scalar_negate(&ss, &ss);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 1);
- secp256k1_scalar_set_int(&ss, 1);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 0);
- }
-
- /* Verify signature with message 1 passes. */
- {
- const unsigned char pubkey[33] = {
- 0x02, 0x14, 0x4e, 0x5a, 0x58, 0xef, 0x5b, 0x22,
- 0x6f, 0xd2, 0xe2, 0x07, 0x6a, 0x77, 0xcf, 0x05,
- 0xb4, 0x1d, 0xe7, 0x4a, 0x30, 0x98, 0x27, 0x8c,
- 0x93, 0xe6, 0xe6, 0x3c, 0x0b, 0xc4, 0x73, 0x76,
- 0x25
- };
- const unsigned char pubkey2[33] = {
- 0x02, 0x8a, 0xd5, 0x37, 0xed, 0x73, 0xd9, 0x40,
- 0x1d, 0xa0, 0x33, 0xd2, 0xdc, 0xf0, 0xaf, 0xae,
- 0x34, 0xcf, 0x5f, 0x96, 0x4c, 0x73, 0x28, 0x0f,
- 0x92, 0xc0, 0xf6, 0x9d, 0xd9, 0xb2, 0x09, 0x10,
- 0x62
- };
- const unsigned char csr[32] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x45, 0x51, 0x23, 0x19, 0x50, 0xb7, 0x5f, 0xc4,
- 0x40, 0x2d, 0xa1, 0x72, 0x2f, 0xc9, 0xba, 0xeb
- };
- secp256k1_ge key;
- secp256k1_ge key2;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 1);
- secp256k1_scalar_set_int(&msg, 1);
- secp256k1_scalar_set_b32(&sr, csr, NULL);
- CHECK(secp256k1_eckey_pubkey_parse(&key, pubkey, 33));
- CHECK(secp256k1_eckey_pubkey_parse(&key2, pubkey2, 33));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 1);
- secp256k1_scalar_negate(&ss, &ss);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 1);
- secp256k1_scalar_set_int(&ss, 2);
- secp256k1_scalar_inverse_var(&ss, &ss);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 0);
- }
-
- /* Verify signature with message -1 passes. */
- {
- const unsigned char pubkey[33] = {
- 0x03, 0xaf, 0x97, 0xff, 0x7d, 0x3a, 0xf6, 0xa0,
- 0x02, 0x94, 0xbd, 0x9f, 0x4b, 0x2e, 0xd7, 0x52,
- 0x28, 0xdb, 0x49, 0x2a, 0x65, 0xcb, 0x1e, 0x27,
- 0x57, 0x9c, 0xba, 0x74, 0x20, 0xd5, 0x1d, 0x20,
- 0xf1
- };
- const unsigned char csr[32] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x45, 0x51, 0x23, 0x19, 0x50, 0xb7, 0x5f, 0xc4,
- 0x40, 0x2d, 0xa1, 0x72, 0x2f, 0xc9, 0xba, 0xee
- };
- secp256k1_ge key;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 1);
- secp256k1_scalar_set_int(&msg, 1);
- secp256k1_scalar_negate(&msg, &msg);
- secp256k1_scalar_set_b32(&sr, csr, NULL);
- CHECK(secp256k1_eckey_pubkey_parse(&key, pubkey, 33));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- secp256k1_scalar_negate(&ss, &ss);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- secp256k1_scalar_set_int(&ss, 3);
- secp256k1_scalar_inverse_var(&ss, &ss);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- }
-
- /* Signature where s would be zero. */
- {
- secp256k1_pubkey pubkey;
- size_t siglen;
- int32_t ecount;
- unsigned char signature[72];
- static const unsigned char nonce[32] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- };
- static const unsigned char nonce2[32] = {
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
- 0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,
- 0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x40
- };
- const unsigned char key[32] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- };
- unsigned char msg[32] = {
- 0x86, 0x41, 0x99, 0x81, 0x06, 0x23, 0x44, 0x53,
- 0xaa, 0x5f, 0x9d, 0x6a, 0x31, 0x78, 0xf4, 0xf7,
- 0xb8, 0x12, 0xe0, 0x0b, 0x81, 0x7a, 0x77, 0x62,
- 0x65, 0xdf, 0xdd, 0x31, 0xb9, 0x3e, 0x29, 0xa9,
- };
- ecount = 0;
- secp256k1_context_set_illegal_callback(ctx, counting_illegal_callback_fn, &ecount);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, precomputed_nonce_function, nonce) == 0);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, precomputed_nonce_function, nonce2) == 0);
- msg[31] = 0xaa;
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, precomputed_nonce_function, nonce) == 1);
- CHECK(ecount == 0);
- CHECK(secp256k1_ecdsa_sign(ctx, NULL, msg, key, precomputed_nonce_function, nonce2) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, NULL, key, precomputed_nonce_function, nonce2) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, NULL, precomputed_nonce_function, nonce2) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, precomputed_nonce_function, nonce2) == 1);
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, key) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, NULL, msg, &pubkey) == 0);
- CHECK(ecount == 4);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, NULL, &pubkey) == 0);
- CHECK(ecount == 5);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg, NULL) == 0);
- CHECK(ecount == 6);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg, &pubkey) == 1);
- CHECK(ecount == 6);
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, NULL) == 0);
- CHECK(ecount == 7);
- /* That pubkeyload fails via an ARGCHECK is a little odd but makes sense because pubkeys are an opaque data type. */
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg, &pubkey) == 0);
- CHECK(ecount == 8);
- siglen = 72;
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, NULL, &siglen, &sig) == 0);
- CHECK(ecount == 9);
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, signature, NULL, &sig) == 0);
- CHECK(ecount == 10);
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, signature, &siglen, NULL) == 0);
- CHECK(ecount == 11);
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, signature, &siglen, &sig) == 1);
- CHECK(ecount == 11);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, NULL, signature, siglen) == 0);
- CHECK(ecount == 12);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, NULL, siglen) == 0);
- CHECK(ecount == 13);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, signature, siglen) == 1);
- CHECK(ecount == 13);
- siglen = 10;
- /* Too little room for a signature does not fail via ARGCHECK. */
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, signature, &siglen, &sig) == 0);
- CHECK(ecount == 13);
- ecount = 0;
- CHECK(secp256k1_ecdsa_signature_normalize(ctx, NULL, NULL) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_signature_serialize_compact(ctx, NULL, &sig) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_signature_serialize_compact(ctx, signature, NULL) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_signature_serialize_compact(ctx, signature, &sig) == 1);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_signature_parse_compact(ctx, NULL, signature) == 0);
- CHECK(ecount == 4);
- CHECK(secp256k1_ecdsa_signature_parse_compact(ctx, &sig, NULL) == 0);
- CHECK(ecount == 5);
- CHECK(secp256k1_ecdsa_signature_parse_compact(ctx, &sig, signature) == 1);
- CHECK(ecount == 5);
- memset(signature, 255, 64);
- CHECK(secp256k1_ecdsa_signature_parse_compact(ctx, &sig, signature) == 0);
- CHECK(ecount == 5);
- secp256k1_context_set_illegal_callback(ctx, NULL, NULL);
- }
-
- /* Nonce function corner cases. */
- for (t = 0; t < 2; t++) {
- static const unsigned char zero[32] = {0x00};
- int i;
- unsigned char key[32];
- unsigned char msg[32];
- secp256k1_ecdsa_signature sig2;
- secp256k1_scalar sr[512], ss;
- const unsigned char *extra;
- extra = t == 0 ? NULL : zero;
- memset(msg, 0, 32);
- msg[31] = 1;
- /* High key results in signature failure. */
- memset(key, 0xFF, 32);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, NULL, extra) == 0);
- CHECK(is_empty_signature(&sig));
- /* Zero key results in signature failure. */
- memset(key, 0, 32);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, NULL, extra) == 0);
- CHECK(is_empty_signature(&sig));
- /* Nonce function failure results in signature failure. */
- key[31] = 1;
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, nonce_function_test_fail, extra) == 0);
- CHECK(is_empty_signature(&sig));
- /* The retry loop successfully makes its way to the first good value. */
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, nonce_function_test_retry, extra) == 1);
- CHECK(!is_empty_signature(&sig));
- CHECK(secp256k1_ecdsa_sign(ctx, &sig2, msg, key, nonce_function_rfc6979, extra) == 1);
- CHECK(!is_empty_signature(&sig2));
- CHECK(memcmp(&sig, &sig2, sizeof(sig)) == 0);
- /* The default nonce function is deterministic. */
- CHECK(secp256k1_ecdsa_sign(ctx, &sig2, msg, key, NULL, extra) == 1);
- CHECK(!is_empty_signature(&sig2));
- CHECK(memcmp(&sig, &sig2, sizeof(sig)) == 0);
- /* The default nonce function changes output with different messages. */
- for(i = 0; i < 256; i++) {
- int j;
- msg[0] = i;
- CHECK(secp256k1_ecdsa_sign(ctx, &sig2, msg, key, NULL, extra) == 1);
- CHECK(!is_empty_signature(&sig2));
- secp256k1_ecdsa_signature_load(ctx, &sr[i], &ss, &sig2);
- for (j = 0; j < i; j++) {
- CHECK(!secp256k1_scalar_eq(&sr[i], &sr[j]));
- }
- }
- msg[0] = 0;
- msg[31] = 2;
- /* The default nonce function changes output with different keys. */
- for(i = 256; i < 512; i++) {
- int j;
- key[0] = i - 256;
- CHECK(secp256k1_ecdsa_sign(ctx, &sig2, msg, key, NULL, extra) == 1);
- CHECK(!is_empty_signature(&sig2));
- secp256k1_ecdsa_signature_load(ctx, &sr[i], &ss, &sig2);
- for (j = 0; j < i; j++) {
- CHECK(!secp256k1_scalar_eq(&sr[i], &sr[j]));
- }
- }
- key[0] = 0;
- }
-
- {
- /* Check that optional nonce arguments do not have equivalent effect. */
- const unsigned char zeros[32] = {0};
- unsigned char nonce[32];
- unsigned char nonce2[32];
- unsigned char nonce3[32];
- unsigned char nonce4[32];
- VG_UNDEF(nonce,32);
- VG_UNDEF(nonce2,32);
- VG_UNDEF(nonce3,32);
- VG_UNDEF(nonce4,32);
- CHECK(nonce_function_rfc6979(nonce, zeros, zeros, NULL, NULL, 0) == 1);
- VG_CHECK(nonce,32);
- CHECK(nonce_function_rfc6979(nonce2, zeros, zeros, zeros, NULL, 0) == 1);
- VG_CHECK(nonce2,32);
- CHECK(nonce_function_rfc6979(nonce3, zeros, zeros, NULL, (void *)zeros, 0) == 1);
- VG_CHECK(nonce3,32);
- CHECK(nonce_function_rfc6979(nonce4, zeros, zeros, zeros, (void *)zeros, 0) == 1);
- VG_CHECK(nonce4,32);
- CHECK(memcmp(nonce, nonce2, 32) != 0);
- CHECK(memcmp(nonce, nonce3, 32) != 0);
- CHECK(memcmp(nonce, nonce4, 32) != 0);
- CHECK(memcmp(nonce2, nonce3, 32) != 0);
- CHECK(memcmp(nonce2, nonce4, 32) != 0);
- CHECK(memcmp(nonce3, nonce4, 32) != 0);
- }
-
-
- /* Privkey export where pubkey is the point at infinity. */
- {
- unsigned char privkey[300];
- unsigned char seckey[32] = {
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41,
- };
- size_t outlen = 300;
- CHECK(!ec_privkey_export_der(ctx, privkey, &outlen, seckey, 0));
- outlen = 300;
- CHECK(!ec_privkey_export_der(ctx, privkey, &outlen, seckey, 1));
- }
-}
-
-void run_ecdsa_edge_cases(void) {
- test_ecdsa_edge_cases();
-}
-
-#ifdef ENABLE_OPENSSL_TESTS
-EC_KEY *get_openssl_key(const unsigned char *key32) {
- unsigned char privkey[300];
- size_t privkeylen;
- const unsigned char* pbegin = privkey;
- int compr = secp256k1_rand_bits(1);
- EC_KEY *ec_key = EC_KEY_new_by_curve_name(NID_secp256k1);
- CHECK(ec_privkey_export_der(ctx, privkey, &privkeylen, key32, compr));
- CHECK(d2i_ECPrivateKey(&ec_key, &pbegin, privkeylen));
- CHECK(EC_KEY_check_key(ec_key));
- return ec_key;
-}
-
-void test_ecdsa_openssl(void) {
- secp256k1_gej qj;
- secp256k1_ge q;
- secp256k1_scalar sigr, sigs;
- secp256k1_scalar one;
- secp256k1_scalar msg2;
- secp256k1_scalar key, msg;
- EC_KEY *ec_key;
- unsigned int sigsize = 80;
- size_t secp_sigsize = 80;
- unsigned char message[32];
- unsigned char signature[80];
- unsigned char key32[32];
- secp256k1_rand256_test(message);
- secp256k1_scalar_set_b32(&msg, message, NULL);
- random_scalar_order_test(&key);
- secp256k1_scalar_get_b32(key32, &key);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &qj, &key);
- secp256k1_ge_set_gej(&q, &qj);
- ec_key = get_openssl_key(key32);
- CHECK(ec_key != NULL);
- CHECK(ECDSA_sign(0, message, sizeof(message), signature, &sigsize, ec_key));
- CHECK(secp256k1_ecdsa_sig_parse(&sigr, &sigs, signature, sigsize));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sigr, &sigs, &q, &msg));
- secp256k1_scalar_set_int(&one, 1);
- secp256k1_scalar_add(&msg2, &msg, &one);
- CHECK(!secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sigr, &sigs, &q, &msg2));
-
- random_sign(&sigr, &sigs, &key, &msg, NULL);
- CHECK(secp256k1_ecdsa_sig_serialize(signature, &secp_sigsize, &sigr, &sigs));
- CHECK(ECDSA_verify(0, message, sizeof(message), signature, secp_sigsize, ec_key) == 1);
-
- EC_KEY_free(ec_key);
-}
-
-void run_ecdsa_openssl(void) {
- int i;
- for (i = 0; i < 10*count; i++) {
- test_ecdsa_openssl();
- }
-}
-#endif
-
-#ifdef ENABLE_MODULE_ECDH
-# include "modules/ecdh/tests_impl.h"
-#endif
-
-#ifdef ENABLE_MODULE_SCHNORR
-# include "modules/schnorr/tests_impl.h"
-#endif
-
-#ifdef ENABLE_MODULE_RECOVERY
-# include "modules/recovery/tests_impl.h"
-#endif
-
-int main(int argc, char **argv) {
- unsigned char seed16[16] = {0};
- unsigned char run32[32] = {0};
- /* find iteration count */
- if (argc > 1) {
- count = strtol(argv[1], NULL, 0);
- }
-
- /* find random seed */
- if (argc > 2) {
- int pos = 0;
- const char* ch = argv[2];
- while (pos < 16 && ch[0] != 0 && ch[1] != 0) {
- unsigned short sh;
- if (sscanf(ch, "%2hx", &sh)) {
- seed16[pos] = sh;
- } else {
- break;
- }
- ch += 2;
- pos++;
- }
- } else {
- FILE *frand = fopen("/dev/urandom", "r");
- if ((frand == NULL) || !fread(&seed16, sizeof(seed16), 1, frand)) {
- uint64_t t = time(NULL) * (uint64_t)1337;
- seed16[0] ^= t;
- seed16[1] ^= t >> 8;
- seed16[2] ^= t >> 16;
- seed16[3] ^= t >> 24;
- seed16[4] ^= t >> 32;
- seed16[5] ^= t >> 40;
- seed16[6] ^= t >> 48;
- seed16[7] ^= t >> 56;
- }
- fclose(frand);
- }
- secp256k1_rand_seed(seed16);
-
- printf("test count = %i\n", count);
- printf("random seed = %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n", seed16[0], seed16[1], seed16[2], seed16[3], seed16[4], seed16[5], seed16[6], seed16[7], seed16[8], seed16[9], seed16[10], seed16[11], seed16[12], seed16[13], seed16[14], seed16[15]);
-
- /* initialize */
- run_context_tests();
- ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
- if (secp256k1_rand_bits(1)) {
- secp256k1_rand256(run32);
- CHECK(secp256k1_context_randomize(ctx, secp256k1_rand_bits(1) ? run32 : NULL));
- }
-
- run_rand_bits();
- run_rand_int();
-
- run_sha256_tests();
- run_hmac_sha256_tests();
- run_rfc6979_hmac_sha256_tests();
-
-#ifndef USE_NUM_NONE
- /* num tests */
- run_num_smalltests();
-#endif
-
- /* scalar tests */
- run_scalar_tests();
-
- /* field tests */
- run_field_inv();
- run_field_inv_var();
- run_field_inv_all_var();
- run_field_misc();
- run_field_convert();
- run_sqr();
- run_sqrt();
-
- /* group tests */
- run_ge();
- run_group_decompress();
-
- /* ecmult tests */
- run_wnaf();
- run_point_times_order();
- run_ecmult_chain();
- run_ecmult_constants();
- run_ecmult_gen_blind();
- run_ecmult_const_tests();
- run_ec_combine();
-
- /* endomorphism tests */
-#ifdef USE_ENDOMORPHISM
- run_endomorphism_tests();
-#endif
-
- /* EC point parser test */
- run_ec_pubkey_parse_test();
-
- /* EC key edge cases */
- run_eckey_edge_case_test();
-
-#ifdef ENABLE_MODULE_ECDH
- /* ecdh tests */
- run_ecdh_tests();
-#endif
-
- /* ecdsa tests */
- run_random_pubkeys();
- run_ecdsa_der_parse();
- run_ecdsa_sign_verify();
- run_ecdsa_end_to_end();
- run_ecdsa_edge_cases();
-#ifdef ENABLE_OPENSSL_TESTS
- run_ecdsa_openssl();
-#endif
-
-#ifdef ENABLE_MODULE_SCHNORR
- /* Schnorr tests */
- run_schnorr_tests();
-#endif
-
-#ifdef ENABLE_MODULE_RECOVERY
- /* ECDSA pubkey recovery tests */
- run_recovery_tests();
-#endif
-
- secp256k1_rand256(run32);
- printf("random run = %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n", run32[0], run32[1], run32[2], run32[3], run32[4], run32[5], run32[6], run32[7], run32[8], run32[9], run32[10], run32[11], run32[12], run32[13], run32[14], run32[15]);
-
- /* shutdown */
- secp256k1_context_destroy(ctx);
-
- printf("no problems found\n");
- return 0;
-}
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/tests_exhaustive.c op-geth/crypto/secp256k1/libsecp256k1/src/tests_exhaustive.c
deleted file mode 100644
index b040bb0733ddf1abef0b715b807d3133db37d2f8..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/tests_exhaustive.c
+++ /dev/null
@@ -1,470 +0,0 @@
-/***********************************************************************
- * Copyright (c) 2016 Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <time.h>
-
-#undef USE_ECMULT_STATIC_PRECOMPUTATION
-
-#ifndef EXHAUSTIVE_TEST_ORDER
-/* see group_impl.h for allowable values */
-#define EXHAUSTIVE_TEST_ORDER 13
-#define EXHAUSTIVE_TEST_LAMBDA 9 /* cube root of 1 mod 13 */
-#endif
-
-#include "include/secp256k1.h"
-#include "group.h"
-#include "secp256k1.c"
-#include "testrand_impl.h"
-
-#ifdef ENABLE_MODULE_RECOVERY
-#include "src/modules/recovery/main_impl.h"
-#include "include/secp256k1_recovery.h"
-#endif
-
-/** stolen from tests.c */
-void ge_equals_ge(const secp256k1_ge *a, const secp256k1_ge *b) {
- CHECK(a->infinity == b->infinity);
- if (a->infinity) {
- return;
- }
- CHECK(secp256k1_fe_equal_var(&a->x, &b->x));
- CHECK(secp256k1_fe_equal_var(&a->y, &b->y));
-}
-
-void ge_equals_gej(const secp256k1_ge *a, const secp256k1_gej *b) {
- secp256k1_fe z2s;
- secp256k1_fe u1, u2, s1, s2;
- CHECK(a->infinity == b->infinity);
- if (a->infinity) {
- return;
- }
- /* Check a.x * b.z^2 == b.x && a.y * b.z^3 == b.y, to avoid inverses. */
- secp256k1_fe_sqr(&z2s, &b->z);
- secp256k1_fe_mul(&u1, &a->x, &z2s);
- u2 = b->x; secp256k1_fe_normalize_weak(&u2);
- secp256k1_fe_mul(&s1, &a->y, &z2s); secp256k1_fe_mul(&s1, &s1, &b->z);
- s2 = b->y; secp256k1_fe_normalize_weak(&s2);
- CHECK(secp256k1_fe_equal_var(&u1, &u2));
- CHECK(secp256k1_fe_equal_var(&s1, &s2));
-}
-
-void random_fe(secp256k1_fe *x) {
- unsigned char bin[32];
- do {
- secp256k1_rand256(bin);
- if (secp256k1_fe_set_b32(x, bin)) {
- return;
- }
- } while(1);
-}
-/** END stolen from tests.c */
-
-int secp256k1_nonce_function_smallint(unsigned char *nonce32, const unsigned char *msg32,
- const unsigned char *key32, const unsigned char *algo16,
- void *data, unsigned int attempt) {
- secp256k1_scalar s;
- int *idata = data;
- (void)msg32;
- (void)key32;
- (void)algo16;
- /* Some nonces cannot be used because they'd cause s and/or r to be zero.
- * The signing function has retry logic here that just re-calls the nonce
- * function with an increased `attempt`. So if attempt > 0 this means we
- * need to change the nonce to avoid an infinite loop. */
- if (attempt > 0) {
- *idata = (*idata + 1) % EXHAUSTIVE_TEST_ORDER;
- }
- secp256k1_scalar_set_int(&s, *idata);
- secp256k1_scalar_get_b32(nonce32, &s);
- return 1;
-}
-
-#ifdef USE_ENDOMORPHISM
-void test_exhaustive_endomorphism(const secp256k1_ge *group, int order) {
- int i;
- for (i = 0; i < order; i++) {
- secp256k1_ge res;
- secp256k1_ge_mul_lambda(&res, &group[i]);
- ge_equals_ge(&group[i * EXHAUSTIVE_TEST_LAMBDA % EXHAUSTIVE_TEST_ORDER], &res);
- }
-}
-#endif
-
-void test_exhaustive_addition(const secp256k1_ge *group, const secp256k1_gej *groupj, int order) {
- int i, j;
-
- /* Sanity-check (and check infinity functions) */
- CHECK(secp256k1_ge_is_infinity(&group[0]));
- CHECK(secp256k1_gej_is_infinity(&groupj[0]));
- for (i = 1; i < order; i++) {
- CHECK(!secp256k1_ge_is_infinity(&group[i]));
- CHECK(!secp256k1_gej_is_infinity(&groupj[i]));
- }
-
- /* Check all addition formulae */
- for (j = 0; j < order; j++) {
- secp256k1_fe fe_inv;
- secp256k1_fe_inv(&fe_inv, &groupj[j].z);
- for (i = 0; i < order; i++) {
- secp256k1_ge zless_gej;
- secp256k1_gej tmp;
- /* add_var */
- secp256k1_gej_add_var(&tmp, &groupj[i], &groupj[j], NULL);
- ge_equals_gej(&group[(i + j) % order], &tmp);
- /* add_ge */
- if (j > 0) {
- secp256k1_gej_add_ge(&tmp, &groupj[i], &group[j]);
- ge_equals_gej(&group[(i + j) % order], &tmp);
- }
- /* add_ge_var */
- secp256k1_gej_add_ge_var(&tmp, &groupj[i], &group[j], NULL);
- ge_equals_gej(&group[(i + j) % order], &tmp);
- /* add_zinv_var */
- zless_gej.infinity = groupj[j].infinity;
- zless_gej.x = groupj[j].x;
- zless_gej.y = groupj[j].y;
- secp256k1_gej_add_zinv_var(&tmp, &groupj[i], &zless_gej, &fe_inv);
- ge_equals_gej(&group[(i + j) % order], &tmp);
- }
- }
-
- /* Check doubling */
- for (i = 0; i < order; i++) {
- secp256k1_gej tmp;
- if (i > 0) {
- secp256k1_gej_double_nonzero(&tmp, &groupj[i], NULL);
- ge_equals_gej(&group[(2 * i) % order], &tmp);
- }
- secp256k1_gej_double_var(&tmp, &groupj[i], NULL);
- ge_equals_gej(&group[(2 * i) % order], &tmp);
- }
-
- /* Check negation */
- for (i = 1; i < order; i++) {
- secp256k1_ge tmp;
- secp256k1_gej tmpj;
- secp256k1_ge_neg(&tmp, &group[i]);
- ge_equals_ge(&group[order - i], &tmp);
- secp256k1_gej_neg(&tmpj, &groupj[i]);
- ge_equals_gej(&group[order - i], &tmpj);
- }
-}
-
-void test_exhaustive_ecmult(const secp256k1_context *ctx, const secp256k1_ge *group, const secp256k1_gej *groupj, int order) {
- int i, j, r_log;
- for (r_log = 1; r_log < order; r_log++) {
- for (j = 0; j < order; j++) {
- for (i = 0; i < order; i++) {
- secp256k1_gej tmp;
- secp256k1_scalar na, ng;
- secp256k1_scalar_set_int(&na, i);
- secp256k1_scalar_set_int(&ng, j);
-
- secp256k1_ecmult(&ctx->ecmult_ctx, &tmp, &groupj[r_log], &na, &ng);
- ge_equals_gej(&group[(i * r_log + j) % order], &tmp);
-
- if (i > 0) {
- secp256k1_ecmult_const(&tmp, &group[i], &ng);
- ge_equals_gej(&group[(i * j) % order], &tmp);
- }
- }
- }
- }
-}
-
-void r_from_k(secp256k1_scalar *r, const secp256k1_ge *group, int k) {
- secp256k1_fe x;
- unsigned char x_bin[32];
- k %= EXHAUSTIVE_TEST_ORDER;
- x = group[k].x;
- secp256k1_fe_normalize(&x);
- secp256k1_fe_get_b32(x_bin, &x);
- secp256k1_scalar_set_b32(r, x_bin, NULL);
-}
-
-void test_exhaustive_verify(const secp256k1_context *ctx, const secp256k1_ge *group, int order) {
- int s, r, msg, key;
- for (s = 1; s < order; s++) {
- for (r = 1; r < order; r++) {
- for (msg = 1; msg < order; msg++) {
- for (key = 1; key < order; key++) {
- secp256k1_ge nonconst_ge;
- secp256k1_ecdsa_signature sig;
- secp256k1_pubkey pk;
- secp256k1_scalar sk_s, msg_s, r_s, s_s;
- secp256k1_scalar s_times_k_s, msg_plus_r_times_sk_s;
- int k, should_verify;
- unsigned char msg32[32];
-
- secp256k1_scalar_set_int(&s_s, s);
- secp256k1_scalar_set_int(&r_s, r);
- secp256k1_scalar_set_int(&msg_s, msg);
- secp256k1_scalar_set_int(&sk_s, key);
-
- /* Verify by hand */
- /* Run through every k value that gives us this r and check that *one* works.
- * Note there could be none, there could be multiple, ECDSA is weird. */
- should_verify = 0;
- for (k = 0; k < order; k++) {
- secp256k1_scalar check_x_s;
- r_from_k(&check_x_s, group, k);
- if (r_s == check_x_s) {
- secp256k1_scalar_set_int(&s_times_k_s, k);
- secp256k1_scalar_mul(&s_times_k_s, &s_times_k_s, &s_s);
- secp256k1_scalar_mul(&msg_plus_r_times_sk_s, &r_s, &sk_s);
- secp256k1_scalar_add(&msg_plus_r_times_sk_s, &msg_plus_r_times_sk_s, &msg_s);
- should_verify |= secp256k1_scalar_eq(&s_times_k_s, &msg_plus_r_times_sk_s);
- }
- }
- /* nb we have a "high s" rule */
- should_verify &= !secp256k1_scalar_is_high(&s_s);
-
- /* Verify by calling verify */
- secp256k1_ecdsa_signature_save(&sig, &r_s, &s_s);
- memcpy(&nonconst_ge, &group[sk_s], sizeof(nonconst_ge));
- secp256k1_pubkey_save(&pk, &nonconst_ge);
- secp256k1_scalar_get_b32(msg32, &msg_s);
- CHECK(should_verify ==
- secp256k1_ecdsa_verify(ctx, &sig, msg32, &pk));
- }
- }
- }
- }
-}
-
-void test_exhaustive_sign(const secp256k1_context *ctx, const secp256k1_ge *group, int order) {
- int i, j, k;
-
- /* Loop */
- for (i = 1; i < order; i++) { /* message */
- for (j = 1; j < order; j++) { /* key */
- for (k = 1; k < order; k++) { /* nonce */
- const int starting_k = k;
- secp256k1_ecdsa_signature sig;
- secp256k1_scalar sk, msg, r, s, expected_r;
- unsigned char sk32[32], msg32[32];
- secp256k1_scalar_set_int(&msg, i);
- secp256k1_scalar_set_int(&sk, j);
- secp256k1_scalar_get_b32(sk32, &sk);
- secp256k1_scalar_get_b32(msg32, &msg);
-
- secp256k1_ecdsa_sign(ctx, &sig, msg32, sk32, secp256k1_nonce_function_smallint, &k);
-
- secp256k1_ecdsa_signature_load(ctx, &r, &s, &sig);
- /* Note that we compute expected_r *after* signing -- this is important
- * because our nonce-computing function function might change k during
- * signing. */
- r_from_k(&expected_r, group, k);
- CHECK(r == expected_r);
- CHECK((k * s) % order == (i + r * j) % order ||
- (k * (EXHAUSTIVE_TEST_ORDER - s)) % order == (i + r * j) % order);
-
- /* Overflow means we've tried every possible nonce */
- if (k < starting_k) {
- break;
- }
- }
- }
- }
-
- /* We would like to verify zero-knowledge here by counting how often every
- * possible (s, r) tuple appears, but because the group order is larger
- * than the field order, when coercing the x-values to scalar values, some
- * appear more often than others, so we are actually not zero-knowledge.
- * (This effect also appears in the real code, but the difference is on the
- * order of 1/2^128th the field order, so the deviation is not useful to a
- * computationally bounded attacker.)
- */
-}
-
-#ifdef ENABLE_MODULE_RECOVERY
-void test_exhaustive_recovery_sign(const secp256k1_context *ctx, const secp256k1_ge *group, int order) {
- int i, j, k;
-
- /* Loop */
- for (i = 1; i < order; i++) { /* message */
- for (j = 1; j < order; j++) { /* key */
- for (k = 1; k < order; k++) { /* nonce */
- const int starting_k = k;
- secp256k1_fe r_dot_y_normalized;
- secp256k1_ecdsa_recoverable_signature rsig;
- secp256k1_ecdsa_signature sig;
- secp256k1_scalar sk, msg, r, s, expected_r;
- unsigned char sk32[32], msg32[32];
- int expected_recid;
- int recid;
- secp256k1_scalar_set_int(&msg, i);
- secp256k1_scalar_set_int(&sk, j);
- secp256k1_scalar_get_b32(sk32, &sk);
- secp256k1_scalar_get_b32(msg32, &msg);
-
- secp256k1_ecdsa_sign_recoverable(ctx, &rsig, msg32, sk32, secp256k1_nonce_function_smallint, &k);
-
- /* Check directly */
- secp256k1_ecdsa_recoverable_signature_load(ctx, &r, &s, &recid, &rsig);
- r_from_k(&expected_r, group, k);
- CHECK(r == expected_r);
- CHECK((k * s) % order == (i + r * j) % order ||
- (k * (EXHAUSTIVE_TEST_ORDER - s)) % order == (i + r * j) % order);
- /* In computing the recid, there is an overflow condition that is disabled in
- * scalar_low_impl.h `secp256k1_scalar_set_b32` because almost every r.y value
- * will exceed the group order, and our signing code always holds out for r
- * values that don't overflow, so with a proper overflow check the tests would
- * loop indefinitely. */
- r_dot_y_normalized = group[k].y;
- secp256k1_fe_normalize(&r_dot_y_normalized);
- /* Also the recovery id is flipped depending if we hit the low-s branch */
- if ((k * s) % order == (i + r * j) % order) {
- expected_recid = secp256k1_fe_is_odd(&r_dot_y_normalized) ? 1 : 0;
- } else {
- expected_recid = secp256k1_fe_is_odd(&r_dot_y_normalized) ? 0 : 1;
- }
- CHECK(recid == expected_recid);
-
- /* Convert to a standard sig then check */
- secp256k1_ecdsa_recoverable_signature_convert(ctx, &sig, &rsig);
- secp256k1_ecdsa_signature_load(ctx, &r, &s, &sig);
- /* Note that we compute expected_r *after* signing -- this is important
- * because our nonce-computing function function might change k during
- * signing. */
- r_from_k(&expected_r, group, k);
- CHECK(r == expected_r);
- CHECK((k * s) % order == (i + r * j) % order ||
- (k * (EXHAUSTIVE_TEST_ORDER - s)) % order == (i + r * j) % order);
-
- /* Overflow means we've tried every possible nonce */
- if (k < starting_k) {
- break;
- }
- }
- }
- }
-}
-
-void test_exhaustive_recovery_verify(const secp256k1_context *ctx, const secp256k1_ge *group, int order) {
- /* This is essentially a copy of test_exhaustive_verify, with recovery added */
- int s, r, msg, key;
- for (s = 1; s < order; s++) {
- for (r = 1; r < order; r++) {
- for (msg = 1; msg < order; msg++) {
- for (key = 1; key < order; key++) {
- secp256k1_ge nonconst_ge;
- secp256k1_ecdsa_recoverable_signature rsig;
- secp256k1_ecdsa_signature sig;
- secp256k1_pubkey pk;
- secp256k1_scalar sk_s, msg_s, r_s, s_s;
- secp256k1_scalar s_times_k_s, msg_plus_r_times_sk_s;
- int recid = 0;
- int k, should_verify;
- unsigned char msg32[32];
-
- secp256k1_scalar_set_int(&s_s, s);
- secp256k1_scalar_set_int(&r_s, r);
- secp256k1_scalar_set_int(&msg_s, msg);
- secp256k1_scalar_set_int(&sk_s, key);
- secp256k1_scalar_get_b32(msg32, &msg_s);
-
- /* Verify by hand */
- /* Run through every k value that gives us this r and check that *one* works.
- * Note there could be none, there could be multiple, ECDSA is weird. */
- should_verify = 0;
- for (k = 0; k < order; k++) {
- secp256k1_scalar check_x_s;
- r_from_k(&check_x_s, group, k);
- if (r_s == check_x_s) {
- secp256k1_scalar_set_int(&s_times_k_s, k);
- secp256k1_scalar_mul(&s_times_k_s, &s_times_k_s, &s_s);
- secp256k1_scalar_mul(&msg_plus_r_times_sk_s, &r_s, &sk_s);
- secp256k1_scalar_add(&msg_plus_r_times_sk_s, &msg_plus_r_times_sk_s, &msg_s);
- should_verify |= secp256k1_scalar_eq(&s_times_k_s, &msg_plus_r_times_sk_s);
- }
- }
- /* nb we have a "high s" rule */
- should_verify &= !secp256k1_scalar_is_high(&s_s);
-
- /* We would like to try recovering the pubkey and checking that it matches,
- * but pubkey recovery is impossible in the exhaustive tests (the reason
- * being that there are 12 nonzero r values, 12 nonzero points, and no
- * overlap between the sets, so there are no valid signatures). */
-
- /* Verify by converting to a standard signature and calling verify */
- secp256k1_ecdsa_recoverable_signature_save(&rsig, &r_s, &s_s, recid);
- secp256k1_ecdsa_recoverable_signature_convert(ctx, &sig, &rsig);
- memcpy(&nonconst_ge, &group[sk_s], sizeof(nonconst_ge));
- secp256k1_pubkey_save(&pk, &nonconst_ge);
- CHECK(should_verify ==
- secp256k1_ecdsa_verify(ctx, &sig, msg32, &pk));
- }
- }
- }
- }
-}
-#endif
-
-int main(void) {
- int i;
- secp256k1_gej groupj[EXHAUSTIVE_TEST_ORDER];
- secp256k1_ge group[EXHAUSTIVE_TEST_ORDER];
-
- /* Build context */
- secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
-
- /* TODO set z = 1, then do num_tests runs with random z values */
-
- /* Generate the entire group */
- secp256k1_gej_set_infinity(&groupj[0]);
- secp256k1_ge_set_gej(&group[0], &groupj[0]);
- for (i = 1; i < EXHAUSTIVE_TEST_ORDER; i++) {
- /* Set a different random z-value for each Jacobian point */
- secp256k1_fe z;
- random_fe(&z);
-
- secp256k1_gej_add_ge(&groupj[i], &groupj[i - 1], &secp256k1_ge_const_g);
- secp256k1_ge_set_gej(&group[i], &groupj[i]);
- secp256k1_gej_rescale(&groupj[i], &z);
-
- /* Verify against ecmult_gen */
- {
- secp256k1_scalar scalar_i;
- secp256k1_gej generatedj;
- secp256k1_ge generated;
-
- secp256k1_scalar_set_int(&scalar_i, i);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &generatedj, &scalar_i);
- secp256k1_ge_set_gej(&generated, &generatedj);
-
- CHECK(group[i].infinity == 0);
- CHECK(generated.infinity == 0);
- CHECK(secp256k1_fe_equal_var(&generated.x, &group[i].x));
- CHECK(secp256k1_fe_equal_var(&generated.y, &group[i].y));
- }
- }
-
- /* Run the tests */
-#ifdef USE_ENDOMORPHISM
- test_exhaustive_endomorphism(group, EXHAUSTIVE_TEST_ORDER);
-#endif
- test_exhaustive_addition(group, groupj, EXHAUSTIVE_TEST_ORDER);
- test_exhaustive_ecmult(ctx, group, groupj, EXHAUSTIVE_TEST_ORDER);
- test_exhaustive_sign(ctx, group, EXHAUSTIVE_TEST_ORDER);
- test_exhaustive_verify(ctx, group, EXHAUSTIVE_TEST_ORDER);
-
-#ifdef ENABLE_MODULE_RECOVERY
- test_exhaustive_recovery_sign(ctx, group, EXHAUSTIVE_TEST_ORDER);
- test_exhaustive_recovery_verify(ctx, group, EXHAUSTIVE_TEST_ORDER);
-#endif
-
- secp256k1_context_destroy(ctx);
- return 0;
-}
-
diff --git go-ethereum/crypto/secp256k1/libsecp256k1/src/util.h op-geth/crypto/secp256k1/libsecp256k1/src/util.h
deleted file mode 100644
index 4092a86c9175cb7815cd4ebe5cf791940f72fb47..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/libsecp256k1/src/util.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_UTIL_H_
-#define _SECP256K1_UTIL_H_
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-
-typedef struct {
- void (*fn)(const char *text, void* data);
- const void* data;
-} secp256k1_callback;
-
-static SECP256K1_INLINE void secp256k1_callback_call(const secp256k1_callback * const cb, const char * const text) {
- cb->fn(text, (void*)cb->data);
-}
-
-#ifdef DETERMINISTIC
-#define TEST_FAILURE(msg) do { \
- fprintf(stderr, "%s\n", msg); \
- abort(); \
-} while(0);
-#else
-#define TEST_FAILURE(msg) do { \
- fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, msg); \
- abort(); \
-} while(0)
-#endif
-
-#ifdef HAVE_BUILTIN_EXPECT
-#define EXPECT(x,c) __builtin_expect((x),(c))
-#else
-#define EXPECT(x,c) (x)
-#endif
-
-#ifdef DETERMINISTIC
-#define CHECK(cond) do { \
- if (EXPECT(!(cond), 0)) { \
- TEST_FAILURE("test condition failed"); \
- } \
-} while(0)
-#else
-#define CHECK(cond) do { \
- if (EXPECT(!(cond), 0)) { \
- TEST_FAILURE("test condition failed: " #cond); \
- } \
-} while(0)
-#endif
-
-/* Like assert(), but when VERIFY is defined, and side-effect safe. */
-#if defined(COVERAGE)
-#define VERIFY_CHECK(check)
-#define VERIFY_SETUP(stmt)
-#elif defined(VERIFY)
-#define VERIFY_CHECK CHECK
-#define VERIFY_SETUP(stmt) do { stmt; } while(0)
-#else
-#define VERIFY_CHECK(cond) do { (void)(cond); } while(0)
-#define VERIFY_SETUP(stmt)
-#endif
-
-static SECP256K1_INLINE void *checked_malloc(const secp256k1_callback* cb, size_t size) {
- void *ret = malloc(size);
- if (ret == NULL) {
- secp256k1_callback_call(cb, "Out of memory");
- }
- return ret;
-}
-
-/* Macro for restrict, when available and not in a VERIFY build. */
-#if defined(SECP256K1_BUILD) && defined(VERIFY)
-# define SECP256K1_RESTRICT
-#else
-# if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) )
-# if SECP256K1_GNUC_PREREQ(3,0)
-# define SECP256K1_RESTRICT __restrict__
-# elif (defined(_MSC_VER) && _MSC_VER >= 1400)
-# define SECP256K1_RESTRICT __restrict
-# else
-# define SECP256K1_RESTRICT
-# endif
-# else
-# define SECP256K1_RESTRICT restrict
-# endif
-#endif
-
-#if defined(_WIN32)
-# define I64FORMAT "I64d"
-# define I64uFORMAT "I64u"
-#else
-# define I64FORMAT "lld"
-# define I64uFORMAT "llu"
-#endif
-
-#if defined(HAVE___INT128)
-# if defined(__GNUC__)
-# define SECP256K1_GNUC_EXT __extension__
-# else
-# define SECP256K1_GNUC_EXT
-# endif
-SECP256K1_GNUC_EXT typedef unsigned __int128 uint128_t;
-#endif
-
-#endif
diff --git go-ethereum/crypto/secp256k1/panic_cb.go op-geth/crypto/secp256k1/panic_cb.go
deleted file mode 100644
index a30b04f51b4277cb27e8b0d25e4eb465a4d326d7..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/panic_cb.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be found in
-// the LICENSE file.
-
-//go:build !gofuzz && cgo
-// +build !gofuzz,cgo
-
-package secp256k1
-
-import "C"
-import "unsafe"
-
-// Callbacks for converting libsecp256k1 internal faults into
-// recoverable Go panics.
-
-//export secp256k1GoPanicIllegal
-func secp256k1GoPanicIllegal(msg *C.char, data unsafe.Pointer) {
- panic("illegal argument: " + C.GoString(msg))
-}
-
-//export secp256k1GoPanicError
-func secp256k1GoPanicError(msg *C.char, data unsafe.Pointer) {
- panic("internal error: " + C.GoString(msg))
-}
diff --git go-ethereum/crypto/secp256k1/scalar_mult_cgo.go op-geth/crypto/secp256k1/scalar_mult_cgo.go
deleted file mode 100644
index 8afa9d023b07b035e53628986632c7cedbc8f731..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/scalar_mult_cgo.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be found in
-// the LICENSE file.
-
-//go:build !gofuzz && cgo
-// +build !gofuzz,cgo
-
-package secp256k1
-
-import (
- "math/big"
- "unsafe"
-)
-
-/*
-
-#include "libsecp256k1/include/secp256k1.h"
-
-extern int secp256k1_ext_scalar_mul(const secp256k1_context* ctx, const unsigned char *point, const unsigned char *scalar);
-
-*/
-import "C"
-
-func (BitCurve *BitCurve) ScalarMult(Bx, By *big.Int, scalar []byte) (*big.Int, *big.Int) {
- // Ensure scalar is exactly 32 bytes. We pad always, even if
- // scalar is 32 bytes long, to avoid a timing side channel.
- if len(scalar) > 32 {
- panic("can't handle scalars > 256 bits")
- }
- // NOTE: potential timing issue
- padded := make([]byte, 32)
- copy(padded[32-len(scalar):], scalar)
- scalar = padded
-
- // Do the multiplication in C, updating point.
- point := make([]byte, 64)
- readBits(Bx, point[:32])
- readBits(By, point[32:])
-
- pointPtr := (*C.uchar)(unsafe.Pointer(&point[0]))
- scalarPtr := (*C.uchar)(unsafe.Pointer(&scalar[0]))
- res := C.secp256k1_ext_scalar_mul(context, pointPtr, scalarPtr)
-
- // Unpack the result and clear temporaries.
- x := new(big.Int).SetBytes(point[:32])
- y := new(big.Int).SetBytes(point[32:])
- for i := range point {
- point[i] = 0
- }
- for i := range padded {
- scalar[i] = 0
- }
- if res != 1 {
- return nil, nil
- }
- return x, y
-}
diff --git go-ethereum/crypto/secp256k1/scalar_mult_nocgo.go op-geth/crypto/secp256k1/scalar_mult_nocgo.go
deleted file mode 100644
index 22f53ac6ae65babe70a6a9e7b6ce69a78b0f8d4f..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/scalar_mult_nocgo.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be found in
-// the LICENSE file.
-
-//go:build gofuzz || !cgo
-// +build gofuzz !cgo
-
-package secp256k1
-
-import "math/big"
-
-func (BitCurve *BitCurve) ScalarMult(Bx, By *big.Int, scalar []byte) (*big.Int, *big.Int) {
- panic("ScalarMult is not available when secp256k1 is built without cgo")
-}
diff --git go-ethereum/crypto/secp256k1/secp256.go op-geth/crypto/secp256k1/secp256.go
deleted file mode 100644
index 61abc1eaf04b7e9e31139369bfb34b1d7bf1dfa4..0000000000000000000000000000000000000000
--- go-ethereum/crypto/secp256k1/secp256.go
+++ /dev/null
@@ -1,182 +0,0 @@
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be found in
-// the LICENSE file.
-
-//go:build !gofuzz && cgo
-// +build !gofuzz,cgo
-
-// Package secp256k1 wraps the bitcoin secp256k1 C library.
-package secp256k1
-
-/*
-#cgo CFLAGS: -I./libsecp256k1
-#cgo CFLAGS: -I./libsecp256k1/src/
-
-#ifdef __SIZEOF_INT128__
-# define HAVE___INT128
-# define USE_FIELD_5X52
-# define USE_SCALAR_4X64
-#else
-# define USE_FIELD_10X26
-# define USE_SCALAR_8X32
-#endif
-
-#ifndef NDEBUG
-# define NDEBUG
-#endif
-
-#define USE_ENDOMORPHISM
-#define USE_NUM_NONE
-#define USE_FIELD_INV_BUILTIN
-#define USE_SCALAR_INV_BUILTIN
-#include "./libsecp256k1/src/secp256k1.c"
-#include "./libsecp256k1/src/modules/recovery/main_impl.h"
-#include "ext.h"
-
-typedef void (*callbackFunc) (const char* msg, void* data);
-extern void secp256k1GoPanicIllegal(const char* msg, void* data);
-extern void secp256k1GoPanicError(const char* msg, void* data);
-*/
-import "C"
-
-import (
- "errors"
- "math/big"
- "unsafe"
-)
-
-var context *C.secp256k1_context
-
-func init() {
- // around 20 ms on a modern CPU.
- context = C.secp256k1_context_create_sign_verify()
- C.secp256k1_context_set_illegal_callback(context, C.callbackFunc(C.secp256k1GoPanicIllegal), nil)
- C.secp256k1_context_set_error_callback(context, C.callbackFunc(C.secp256k1GoPanicError), nil)
-}
-
-var (
- ErrInvalidMsgLen = errors.New("invalid message length, need 32 bytes")
- ErrInvalidSignatureLen = errors.New("invalid signature length")
- ErrInvalidRecoveryID = errors.New("invalid signature recovery id")
- ErrInvalidKey = errors.New("invalid private key")
- ErrInvalidPubkey = errors.New("invalid public key")
- ErrSignFailed = errors.New("signing failed")
- ErrRecoverFailed = errors.New("recovery failed")
-)
-
-// Sign creates a recoverable ECDSA signature.
-// The produced signature is in the 65-byte [R || S || V] format where V is 0 or 1.
-//
-// The caller is responsible for ensuring that msg cannot be chosen
-// directly by an attacker. It is usually preferable to use a cryptographic
-// hash function on any input before handing it to this function.
-func Sign(msg []byte, seckey []byte) ([]byte, error) {
- if len(msg) != 32 {
- return nil, ErrInvalidMsgLen
- }
- if len(seckey) != 32 {
- return nil, ErrInvalidKey
- }
- seckeydata := (*C.uchar)(unsafe.Pointer(&seckey[0]))
- if C.secp256k1_ec_seckey_verify(context, seckeydata) != 1 {
- return nil, ErrInvalidKey
- }
-
- var (
- msgdata = (*C.uchar)(unsafe.Pointer(&msg[0]))
- noncefunc = C.secp256k1_nonce_function_rfc6979
- sigstruct C.secp256k1_ecdsa_recoverable_signature
- )
- if C.secp256k1_ecdsa_sign_recoverable(context, &sigstruct, msgdata, seckeydata, noncefunc, nil) == 0 {
- return nil, ErrSignFailed
- }
-
- var (
- sig = make([]byte, 65)
- sigdata = (*C.uchar)(unsafe.Pointer(&sig[0]))
- recid C.int
- )
- C.secp256k1_ecdsa_recoverable_signature_serialize_compact(context, sigdata, &recid, &sigstruct)
- sig[64] = byte(recid) // add back recid to get 65 bytes sig
- return sig, nil
-}
-
-// RecoverPubkey returns the public key of the signer.
-// msg must be the 32-byte hash of the message to be signed.
-// sig must be a 65-byte compact ECDSA signature containing the
-// recovery id as the last element.
-func RecoverPubkey(msg []byte, sig []byte) ([]byte, error) {
- if len(msg) != 32 {
- return nil, ErrInvalidMsgLen
- }
- if err := checkSignature(sig); err != nil {
- return nil, err
- }
-
- var (
- pubkey = make([]byte, 65)
- sigdata = (*C.uchar)(unsafe.Pointer(&sig[0]))
- msgdata = (*C.uchar)(unsafe.Pointer(&msg[0]))
- )
- if C.secp256k1_ext_ecdsa_recover(context, (*C.uchar)(unsafe.Pointer(&pubkey[0])), sigdata, msgdata) == 0 {
- return nil, ErrRecoverFailed
- }
- return pubkey, nil
-}
-
-// VerifySignature checks that the given pubkey created signature over message.
-// The signature should be in [R || S] format.
-func VerifySignature(pubkey, msg, signature []byte) bool {
- if len(msg) != 32 || len(signature) != 64 || len(pubkey) == 0 {
- return false
- }
- sigdata := (*C.uchar)(unsafe.Pointer(&signature[0]))
- msgdata := (*C.uchar)(unsafe.Pointer(&msg[0]))
- keydata := (*C.uchar)(unsafe.Pointer(&pubkey[0]))
- return C.secp256k1_ext_ecdsa_verify(context, sigdata, msgdata, keydata, C.size_t(len(pubkey))) != 0
-}
-
-// DecompressPubkey parses a public key in the 33-byte compressed format.
-// It returns non-nil coordinates if the public key is valid.
-func DecompressPubkey(pubkey []byte) (x, y *big.Int) {
- if len(pubkey) != 33 {
- return nil, nil
- }
- var (
- pubkeydata = (*C.uchar)(unsafe.Pointer(&pubkey[0]))
- pubkeylen = C.size_t(len(pubkey))
- out = make([]byte, 65)
- outdata = (*C.uchar)(unsafe.Pointer(&out[0]))
- outlen = C.size_t(len(out))
- )
- if C.secp256k1_ext_reencode_pubkey(context, outdata, outlen, pubkeydata, pubkeylen) == 0 {
- return nil, nil
- }
- return new(big.Int).SetBytes(out[1:33]), new(big.Int).SetBytes(out[33:])
-}
-
-// CompressPubkey encodes a public key to 33-byte compressed format.
-func CompressPubkey(x, y *big.Int) []byte {
- var (
- pubkey = S256().Marshal(x, y)
- pubkeydata = (*C.uchar)(unsafe.Pointer(&pubkey[0]))
- pubkeylen = C.size_t(len(pubkey))
- out = make([]byte, 33)
- outdata = (*C.uchar)(unsafe.Pointer(&out[0]))
- outlen = C.size_t(len(out))
- )
- if C.secp256k1_ext_reencode_pubkey(context, outdata, outlen, pubkeydata, pubkeylen) == 0 {
- panic("libsecp256k1 error")
- }
- return out
-}
-
-func checkSignature(sig []byte) error {
- if len(sig) != 65 {
- return ErrInvalidSignatureLen
- }
- if sig[64] >= 4 {
- return ErrInvalidRecoveryID
- }
- return nil
-}
diff --git go-ethereum/crypto/secp256r1/publickey.go op-geth/crypto/secp256r1/publickey.go
new file mode 100644
index 0000000000000000000000000000000000000000..885a3e1a624b85310225913c44d294e402a50fcd
--- /dev/null
+++ op-geth/crypto/secp256r1/publickey.go
@@ -0,0 +1,21 @@
+package secp256r1
+
+import (
+ "crypto/ecdsa"
+ "crypto/elliptic"
+ "math/big"
+)
+
+// Generates appropriate public key format from given coordinates
+func newPublicKey(x, y *big.Int) *ecdsa.PublicKey {
+ // Check if the given coordinates are valid
+ if x == nil || y == nil || !elliptic.P256().IsOnCurve(x, y) {
+ return nil
+ }
+
+ return &ecdsa.PublicKey{
+ Curve: elliptic.P256(),
+ X: x,
+ Y: y,
+ }
+}
diff --git go-ethereum/crypto/secp256r1/verifier.go op-geth/crypto/secp256r1/verifier.go
new file mode 100644
index 0000000000000000000000000000000000000000..ffb4839d8d560a5892175c737bff136d73ee6e12
--- /dev/null
+++ op-geth/crypto/secp256r1/verifier.go
@@ -0,0 +1,22 @@
+package secp256r1
+
+import (
+ "crypto/ecdsa"
+ "math/big"
+)
+
+// Verify verifies the given signature (r, s) for the given hash and public key (x, y).
+// It returns true if the signature is valid, false otherwise.
+func Verify(hash []byte, r, s, x, y *big.Int) bool {
+ // Create the public key format
+ publicKey := newPublicKey(x, y)
+
+ // Check if they are invalid public key coordinates
+ if publicKey == nil {
+ return false
+ }
+
+ // Verify the signature with the public key,
+ // then return true if it's valid, false otherwise
+ return ecdsa.Verify(publicKey, hash, r, s)
+}
diff --git go-ethereum/crypto/signature_cgo.go op-geth/crypto/signature_cgo.go
index 2339e5201547a750bbed5ebe6e0fdbd92be68bf3..3ca3b9f94212b9595ddbadda3d973479664aa5b0 100644
--- go-ethereum/crypto/signature_cgo.go
+++ op-geth/crypto/signature_cgo.go
@@ -25,8 +25,8 @@ "crypto/elliptic"
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/common/math"
"github.com/ethereum/go-ethereum/crypto/secp256k1"
+ "github.com/tenderly/op-geth/common/math"
)
// Ecrecover returns the uncompressed public key that created the given signature.
diff --git go-ethereum/docs/postmortems/2021-08-22-split-postmortem.md op-geth/docs/postmortems/2021-08-22-split-postmortem.md
index 0986f00b65c6b8e660e1f980207a038c84b7eb8c..c86a75c91418eca83990149c901ad147a69c3c0b 100644
--- go-ethereum/docs/postmortems/2021-08-22-split-postmortem.md
+++ op-geth/docs/postmortems/2021-08-22-split-postmortem.md
@@ -7,7 +7,7 @@
- 2021-08-17: Guido Vranken submitted a bounty report. Investigation started, root cause identified, patch variations discussed.
- 2021-08-18: Made public announcement over twitter about upcoming security release upcoming Tuesday. Downstream projects were also notified about the upcoming patch-release.
-- 2021-08-24: Released [v1.10.8](https://github.com/ethereum/go-ethereum/releases/tag/v1.10.8) containing the fix on Tuesday morning (CET). Erigon released [v2021.08.04](https://github.com/ledgerwatch/erigon/releases/tag/v2021.08.04).
+- 2021-08-24: Released [v1.10.8](https://github.com/tenderly/op-geth/releases/tag/v1.10.8) containing the fix on Tuesday morning (CET). Erigon released [v2021.08.04](https://github.com/ledgerwatch/erigon/releases/tag/v2021.08.04).
- 2021-08-27: At 12:50:07 UTC, issue exploited. Analysis started roughly 30m later,
@@ -62,7 +62,7 @@ Since we had merged the removal of `ETH65`, if the entire network were to upgrade, then nodes which have not yet implemented `ETH66` would be cut off from the network. After further discussions, we decided to:
- Announce an upcoming security release on Tuesday (August 24th), via Twitter and official channels, plus reach out to downstream projects.
- Temporarily revert the `ETH65`-removal.
-- Place the fix into the PR optimizing the jumpdest analysis [233381](https://github.com/ethereum/go-ethereum/pull/23381).
+- Place the fix into the PR optimizing the jumpdest analysis [233381](https://github.com/tenderly/op-geth/pull/23381).
- After 4-8 weeks, release details about the vulnerability.
diff --git go-ethereum/eth/api.go op-geth/eth/api.go
index 44e934fd040b5d90521f60b3fbd95ee26a2ba67e..5593e948d218c6fb4eaa4e8e8688f301f64940c1 100644
--- go-ethereum/eth/api.go
+++ op-geth/eth/api.go
@@ -17,8 +17,8 @@
package eth
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
// EthereumAPI provides an API to access Ethereum full node-related information.
diff --git go-ethereum/eth/api_admin.go op-geth/eth/api_admin.go
index 4a3ccb84e82dcf004b92e5a53dce42e8fed78e4a..d6f654dd9258a4aaca93522ae5fda61c2e3bb93b 100644
--- go-ethereum/eth/api_admin.go
+++ op-geth/eth/api_admin.go
@@ -24,9 +24,9 @@ "io"
"os"
"strings"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rlp"
)
// AdminAPI is the collection of Ethereum full node related APIs for node
diff --git go-ethereum/eth/api_miner.go op-geth/eth/api_miner.go
index 764d0ae5e2f50deab73752ef29811b4b6afc6795..1fcfab82de23de46f46f1c7e9adc33e41ce31073 100644
--- go-ethereum/eth/api_miner.go
+++ op-geth/eth/api_miner.go
@@ -20,8 +20,8 @@ import (
"math/big"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
// MinerAPI provides an API to control the miner.
diff --git go-ethereum/eth/bloombits.go op-geth/eth/bloombits.go
index 0cb7050d2327f64efa085bfae37d523420d3602c..73f305f37bf0ca85960c30715689d44da43a833c 100644
--- go-ethereum/eth/bloombits.go
+++ op-geth/eth/bloombits.go
@@ -19,8 +19,8 @@
import (
"time"
- "github.com/ethereum/go-ethereum/common/bitutil"
- "github.com/ethereum/go-ethereum/core/rawdb"
+ "github.com/tenderly/op-geth/common/bitutil"
+ "github.com/tenderly/op-geth/core/rawdb"
)
const (
diff --git go-ethereum/eth/catalyst/queue.go op-geth/eth/catalyst/queue.go
index 634dc1b2e6c2520f02e74f38ba66cba649685c86..f10f16444fc27fb3728f168de7dbc13c73ee891e 100644
--- go-ethereum/eth/catalyst/queue.go
+++ op-geth/eth/catalyst/queue.go
@@ -17,12 +17,13 @@
package catalyst
import (
+ "errors"
"sync"
- "github.com/ethereum/go-ethereum/beacon/engine"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/miner"
+ "github.com/tenderly/op-geth/beacon/engine"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/miner"
)
// maxTrackedPayloads is the maximum number of prepared payloads the execution
@@ -89,6 +90,24 @@ return item.payload.ResolveFull()
}
}
return nil
+}
+
+// waitFull waits until the first full payload has been built for the specified payload id
+// The method returns immediately if the payload is unknown.
+func (q *payloadQueue) waitFull(id engine.PayloadID) error {
+ q.lock.RLock()
+ defer q.lock.RUnlock()
+
+ for _, item := range q.payloads {
+ if item == nil {
+ return errors.New("unknown payload")
+ }
+ if item.id == id {
+ item.payload.WaitFull()
+ return nil
+ }
+ }
+ return errors.New("unknown payload")
}
// has checks if a particular payload is already tracked.
diff --git go-ethereum/eth/catalyst/simulated_beacon.go op-geth/eth/catalyst/simulated_beacon.go
index f1c5689e1d286880cef5c8b4950dc28282d136a1..4cfe7e4896d01128576bf01b5a57be16aa0534fa 100644
--- go-ethereum/eth/catalyst/simulated_beacon.go
+++ op-geth/eth/catalyst/simulated_beacon.go
@@ -23,15 +23,15 @@ "math/big"
"sync"
"time"
- "github.com/ethereum/go-ethereum/beacon/engine"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/beacon/engine"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
const devEpochLength = 32
@@ -169,6 +169,9 @@ if fcResponse == engine.STATUS_SYNCING {
return errors.New("chain rewind prevented invocation of payload creation")
}
+ if err := c.engineAPI.localBlocks.waitFull(*fcResponse.PayloadID); err != nil {
+ return err
+ }
envelope, err := c.engineAPI.getPayload(*fcResponse.PayloadID, true)
if err != nil {
return err
diff --git go-ethereum/eth/catalyst/simulated_beacon_api.go op-geth/eth/catalyst/simulated_beacon_api.go
index 73d0a5921d83bde85578803aafa98fbce4f04b8a..06d06f5b0d6e46bd2d49f22f7ec6bceb7f1a4519 100644
--- go-ethereum/eth/catalyst/simulated_beacon_api.go
+++ op-geth/eth/catalyst/simulated_beacon_api.go
@@ -20,10 +20,10 @@ import (
"context"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
)
type api struct {
diff --git go-ethereum/eth/catalyst/tester.go op-geth/eth/catalyst/tester.go
index 0922ac0ba654541a62c3d2d4b13cb0fc3efb0b3f..d49e30463f351d60c1df8de1577e2f499cf28398 100644
--- go-ethereum/eth/catalyst/tester.go
+++ op-geth/eth/catalyst/tester.go
@@ -20,11 +20,11 @@ import (
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/node"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/node"
)
// FullSyncTester is an auxiliary service that allows Geth to perform full sync
diff --git go-ethereum/eth/downloader/api.go op-geth/eth/downloader/api.go
index 6b8cb98e23bde46c9b8d7c3ec4b10d0d444425c0..698a56d1c668f7d958125bce1e65618e17e15313 100644
--- go-ethereum/eth/downloader/api.go
+++ op-geth/eth/downloader/api.go
@@ -21,10 +21,10 @@ "context"
"sync"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/rpc"
)
// DownloaderAPI provides an API which gives information about the current
diff --git go-ethereum/eth/downloader/beacondevsync.go op-geth/eth/downloader/beacondevsync.go
index 9a38fedd463e0ea8f5505992ae547105aa3b11ef..31a2df0efa35e70e4be5f595463c6d3da3a340af 100644
--- go-ethereum/eth/downloader/beacondevsync.go
+++ op-geth/eth/downloader/beacondevsync.go
@@ -20,8 +20,8 @@ import (
"errors"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/log"
)
// BeaconDevSync is a development helper to test synchronization by providing
diff --git go-ethereum/eth/downloader/beaconsync.go op-geth/eth/downloader/beaconsync.go
index d3f75c8527031e78aa7b651bcbbae774ed078074..9db8cd96745a7952b3ab9156faebeb2b40d49a95 100644
--- go-ethereum/eth/downloader/beaconsync.go
+++ op-geth/eth/downloader/beaconsync.go
@@ -21,10 +21,10 @@ "fmt"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
)
// beaconBackfiller is the chain and state backfilling that can be commenced once
diff --git go-ethereum/eth/downloader/events.go op-geth/eth/downloader/events.go
index 25255a3a72e5fc930dcefd34051c3d6039a7cfb4..0e0e7c892878a727ac7baea5115f95374b110cc6 100644
--- go-ethereum/eth/downloader/events.go
+++ op-geth/eth/downloader/events.go
@@ -16,7 +16,7 @@ // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
package downloader
-import "github.com/ethereum/go-ethereum/core/types"
+import "github.com/tenderly/op-geth/core/types"
type DoneEvent struct {
Latest *types.Header
diff --git go-ethereum/eth/downloader/fetchers.go op-geth/eth/downloader/fetchers.go
index cc4279b0da7a1d24b6a9f84d94864984fefc400a..9e2f388f447c4bfc10ed85c725c0376ae9400b1b 100644
--- go-ethereum/eth/downloader/fetchers.go
+++ op-geth/eth/downloader/fetchers.go
@@ -19,9 +19,9 @@
import (
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
)
// fetchHeadersByHash is a blocking version of Peer.RequestHeadersByHash which
diff --git go-ethereum/eth/downloader/fetchers_concurrent.go op-geth/eth/downloader/fetchers_concurrent.go
index 649aa27615963c37a436a2e80214f62ce508ef5d..fddd43f5ce7692d832625f381d15ba141898da5c 100644
--- go-ethereum/eth/downloader/fetchers_concurrent.go
+++ op-geth/eth/downloader/fetchers_concurrent.go
@@ -21,10 +21,10 @@ "errors"
"sort"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/prque"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/prque"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/log"
)
// timeoutGracePeriod is the amount of time to allow for a peer to deliver a
diff --git go-ethereum/eth/downloader/fetchers_concurrent_bodies.go op-geth/eth/downloader/fetchers_concurrent_bodies.go
index 5105fda66b3a8752ed512532c8c8770956f1989d..294782e3a4b77a71d6ed51efb1bf4be1a41b5774 100644
--- go-ethereum/eth/downloader/fetchers_concurrent_bodies.go
+++ op-geth/eth/downloader/fetchers_concurrent_bodies.go
@@ -19,9 +19,9 @@
import (
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/log"
)
// bodyQueue implements typedQueue and is a type adapter between the generic
diff --git go-ethereum/eth/downloader/fetchers_concurrent_headers.go op-geth/eth/downloader/fetchers_concurrent_headers.go
index 8201f4ca74232e8e726b98557e453cd70e4166b5..56ad6a508d03f9d8d8c891798b74cda6fd18761b 100644
--- go-ethereum/eth/downloader/fetchers_concurrent_headers.go
+++ op-geth/eth/downloader/fetchers_concurrent_headers.go
@@ -19,9 +19,9 @@
import (
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/log"
)
// headerQueue implements typedQueue and is a type adapter between the generic
diff --git go-ethereum/eth/downloader/fetchers_concurrent_receipts.go op-geth/eth/downloader/fetchers_concurrent_receipts.go
index 3169f030ba1035a029911ed938cbbceb2fc015cd..67baf0f06679dbaa573a3fd60b0239a4e9163a37 100644
--- go-ethereum/eth/downloader/fetchers_concurrent_receipts.go
+++ op-geth/eth/downloader/fetchers_concurrent_receipts.go
@@ -19,9 +19,9 @@
import (
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/log"
)
// receiptQueue implements typedQueue and is a type adapter between the generic
diff --git go-ethereum/eth/downloader/metrics.go op-geth/eth/downloader/metrics.go
index 23c033a8ad12eacbae31ae52be4dd8fc80f10f88..b051374a5ce20408711e5b66e6f017919af69b97 100644
--- go-ethereum/eth/downloader/metrics.go
+++ op-geth/eth/downloader/metrics.go
@@ -19,7 +19,7 @@
package downloader
import (
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/metrics"
)
var (
diff --git go-ethereum/eth/downloader/peer.go op-geth/eth/downloader/peer.go
index 4c43af5270ca88485a96962e7ce0d8b46665619b..4287f45d4c7fc00589bffb12ec341bfa35d53ca1 100644
--- go-ethereum/eth/downloader/peer.go
+++ op-geth/eth/downloader/peer.go
@@ -25,11 +25,11 @@ "math/big"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/msgrate"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/msgrate"
)
const (
diff --git go-ethereum/eth/downloader/queue.go op-geth/eth/downloader/queue.go
index 6ff858d7553e9a749d6bd072669737388ef9ebee..6b9c8d0dbc086b1536cf598feca4bc8c09cf14a1 100644
--- go-ethereum/eth/downloader/queue.go
+++ op-geth/eth/downloader/queue.go
@@ -26,13 +26,13 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/prque"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/prque"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/params"
)
const (
diff --git go-ethereum/eth/downloader/resultstore.go op-geth/eth/downloader/resultstore.go
index e4323c04ebc57d08f62f5aaea3fe7ad4f7da9eae..8b19f380b511fc9852a92de603cdd88c8d607350 100644
--- go-ethereum/eth/downloader/resultstore.go
+++ op-geth/eth/downloader/resultstore.go
@@ -21,7 +21,7 @@ "fmt"
"sync"
"sync/atomic"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/core/types"
)
// resultStore implements a structure for maintaining fetchResults, tracking their
diff --git go-ethereum/eth/downloader/skeleton.go op-geth/eth/downloader/skeleton.go
index 873ee950b66c63e7a2b7c5968c484651424d56e5..5b755946ad781687fd911dedb301f40dd14054d7 100644
--- go-ethereum/eth/downloader/skeleton.go
+++ op-geth/eth/downloader/skeleton.go
@@ -24,12 +24,12 @@ "math/rand"
"sort"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
)
// scratchHeaders is the number of headers to store in a scratch space to allow
diff --git go-ethereum/eth/downloader/statesync.go op-geth/eth/downloader/statesync.go
index 501af63ed5c405ebee4fe3fa24d3e3168ecce59c..1145157b80f7dc1b8b44a03e90b6d5d86afff775 100644
--- go-ethereum/eth/downloader/statesync.go
+++ op-geth/eth/downloader/statesync.go
@@ -19,8 +19,8 @@
import (
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/log"
)
// syncState starts downloading state with the given root hash.
diff --git go-ethereum/eth/fetcher/block_fetcher.go op-geth/eth/fetcher/block_fetcher.go
index 126eaaea7fad244d0257c2a8b5f4f5b63ac52406..bfa2eb5bcb27d072526ad560e1828024206733b0 100644
--- go-ethereum/eth/fetcher/block_fetcher.go
+++ op-geth/eth/fetcher/block_fetcher.go
@@ -22,14 +22,14 @@ "errors"
"math/rand"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/prque"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/prque"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/trie"
)
const (
diff --git go-ethereum/eth/fetcher/tx_fetcher.go op-geth/eth/fetcher/tx_fetcher.go
index ea7892d8d84e562a3d82d0976cb490ccdcbfdafb..89d2e07e3c69171bada8b7469e8c9f382adc98ef 100644
--- go-ethereum/eth/fetcher/tx_fetcher.go
+++ op-geth/eth/fetcher/tx_fetcher.go
@@ -25,13 +25,13 @@ mrand "math/rand"
"sort"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
const (
diff --git go-ethereum/eth/filters/api.go op-geth/eth/filters/api.go
index 173e40c972248abf1f48582dacc5545f3e9bdae6..c5d76f2ea71e2d3332058bb39d01358ab430bccc 100644
--- go-ethereum/eth/filters/api.go
+++ op-geth/eth/filters/api.go
@@ -25,12 +25,12 @@ "math/big"
"sync"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/rpc"
)
var (
diff --git go-ethereum/eth/filters/filter.go op-geth/eth/filters/filter.go
index 83e3284a2b5b8465943d6f2574451f403afcb304..f80bd9180a305191b514de5f37f6e79aea18f5ef 100644
--- go-ethereum/eth/filters/filter.go
+++ op-geth/eth/filters/filter.go
@@ -21,10 +21,10 @@ "context"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/bloombits"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/bloombits"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rpc"
)
// Filter can be used to retrieve and filter logs.
diff --git go-ethereum/eth/filters/filter_system.go op-geth/eth/filters/filter_system.go
index f98a1f84ce14fddda6df1723cf050e46ece2325d..ab76bbbb60dd808d649e0df84d608ffe44e573dc 100644
--- go-ethereum/eth/filters/filter_system.go
+++ op-geth/eth/filters/filter_system.go
@@ -25,18 +25,18 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/bloombits"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/bloombits"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
// Config represents the configuration of the filter system.
diff --git go-ethereum/eth/gasestimator/gasestimator.go op-geth/eth/gasestimator/gasestimator.go
index f07f98956e3c8a483f14e693569f096837d899a0..0adb4ec42d1b7c952daa4cc7107471a4ab0c32bd 100644
--- go-ethereum/eth/gasestimator/gasestimator.go
+++ op-geth/eth/gasestimator/gasestimator.go
@@ -23,13 +23,13 @@ "fmt"
"math"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
)
// Options are the contextual parameters to execute the requested call.
@@ -208,7 +208,7 @@ func run(ctx context.Context, call *core.Message, opts *Options) (*core.ExecutionResult, error) {
// Assemble the call and the call context
var (
msgContext = core.NewEVMTxContext(call)
- evmContext = core.NewEVMBlockContext(opts.Header, opts.Chain, nil)
+ evmContext = core.NewEVMBlockContext(opts.Header, opts.Chain, nil, opts.Config, opts.State)
dirtyState = opts.State.Copy()
evm = vm.NewEVM(evmContext, msgContext, dirtyState, opts.Config, vm.Config{NoBaseFee: true})
diff --git go-ethereum/eth/gasprice/feehistory.go op-geth/eth/gasprice/feehistory.go
index d657eb6d996b6f7eb7eecfb6bab2f4a3b63d8970..dc37bef4512ba8db3e289307db2e9ab5d9edb126 100644
--- go-ethereum/eth/gasprice/feehistory.go
+++ op-geth/eth/gasprice/feehistory.go
@@ -25,11 +25,11 @@ "math"
"math/big"
"sync/atomic"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rpc"
"golang.org/x/exp/slices"
)
@@ -83,7 +83,7 @@ if bf.results.baseFee = bf.header.BaseFee; bf.results.baseFee == nil {
bf.results.baseFee = new(big.Int)
}
if chainconfig.IsLondon(big.NewInt(int64(bf.blockNumber + 1))) {
- bf.results.nextBaseFee = eip1559.CalcBaseFee(chainconfig, bf.header)
+ bf.results.nextBaseFee = eip1559.CalcBaseFee(chainconfig, bf.header, bf.header.Time+1)
} else {
bf.results.nextBaseFee = new(big.Int)
}
diff --git go-ethereum/eth/handler_snap.go op-geth/eth/handler_snap.go
index 767416ffd650e6b61850c4462a779ed92c9efc7e..3cc15bbba3c571527806abfaba0365de5b20e580 100644
--- go-ethereum/eth/handler_snap.go
+++ op-geth/eth/handler_snap.go
@@ -17,9 +17,9 @@
package eth
import (
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/eth/protocols/snap"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/eth/protocols/snap"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// snapHandler implements the snap.Backend interface to handle the various network
diff --git go-ethereum/eth/peer.go op-geth/eth/peer.go
index 7618777716600afe253657dff857907d37af2d45..5cd083d5d4b22ca92bc7d7fdbcbb998069e5b8fc 100644
--- go-ethereum/eth/peer.go
+++ op-geth/eth/peer.go
@@ -17,8 +17,8 @@
package eth
import (
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/eth/protocols/snap"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/eth/protocols/snap"
)
// ethPeerInfo represents a short summary of the `eth` sub-protocol metadata known
diff --git go-ethereum/eth/peerset.go op-geth/eth/peerset.go
index c0c11e3e85eee1120c94f40a5cae8bc59c77e612..10a55f3798abca4a9f552481e95a3115dd51a27b 100644
--- go-ethereum/eth/peerset.go
+++ op-geth/eth/peerset.go
@@ -22,10 +22,10 @@ "fmt"
"math/big"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/eth/protocols/snap"
- "github.com/ethereum/go-ethereum/p2p"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/eth/protocols/snap"
+ "github.com/tenderly/op-geth/p2p"
)
var (
diff --git go-ethereum/eth/protocols/eth/broadcast.go op-geth/eth/protocols/eth/broadcast.go
index ad5395cb8dd9de2b7685312a8f0e0d840b239e69..3db69429589e3195e46bc99317842851d56c11ce 100644
--- go-ethereum/eth/protocols/eth/broadcast.go
+++ op-geth/eth/protocols/eth/broadcast.go
@@ -19,8 +19,8 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
)
const (
diff --git go-ethereum/eth/protocols/eth/discovery.go op-geth/eth/protocols/eth/discovery.go
index a7bdd47daf07df237acf996a002bb1d956ea2eb8..9fa2d4067cc85b926a9a3f00e1996a1f9f27d039 100644
--- go-ethereum/eth/protocols/eth/discovery.go
+++ op-geth/eth/protocols/eth/discovery.go
@@ -17,10 +17,10 @@
package eth
import (
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/forkid"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/forkid"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/rlp"
)
// enrEntry is the ENR entry which advertises `eth` protocol on the discovery.
diff --git go-ethereum/eth/protocols/eth/dispatcher.go op-geth/eth/protocols/eth/dispatcher.go
index ae98820cd6acb8e8e9b6e7e80db94936443a4bdb..60267cd1852d1b4bf81f81e6a3a704328e93d3eb 100644
--- go-ethereum/eth/protocols/eth/dispatcher.go
+++ op-geth/eth/protocols/eth/dispatcher.go
@@ -21,7 +21,7 @@ "errors"
"fmt"
"time"
- "github.com/ethereum/go-ethereum/p2p"
+ "github.com/tenderly/op-geth/p2p"
)
var (
diff --git go-ethereum/eth/protocols/eth/handler.go op-geth/eth/protocols/eth/handler.go
index 2d69ecdc83665355fa3d03befa80bc9f457e1ca3..d378766ca94a9e3096450c75028fe26f098a62dd 100644
--- go-ethereum/eth/protocols/eth/handler.go
+++ op-geth/eth/protocols/eth/handler.go
@@ -21,14 +21,14 @@ "fmt"
"math/big"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/params"
)
const (
diff --git go-ethereum/eth/protocols/eth/handlers.go op-geth/eth/protocols/eth/handlers.go
index 0275708a6cd51e63acd04062f809f63eba57e449..30d4b62293ec8a46cab96fc28cd92723930aa53f 100644
--- go-ethereum/eth/protocols/eth/handlers.go
+++ op-geth/eth/protocols/eth/handlers.go
@@ -20,12 +20,12 @@ import (
"encoding/json"
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
)
func handleGetBlockHeaders(backend Backend, msg Decoder, peer *Peer) error {
diff --git go-ethereum/eth/protocols/eth/handshake.go op-geth/eth/protocols/eth/handshake.go
index ea16a85b1e1eb0275784ff5dcd6de70818b4d221..93a3ea5687861d760743a4757547d06639e655f8 100644
--- go-ethereum/eth/protocols/eth/handshake.go
+++ op-geth/eth/protocols/eth/handshake.go
@@ -22,10 +22,10 @@ "fmt"
"math/big"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/forkid"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/p2p"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/forkid"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/p2p"
)
const (
diff --git go-ethereum/eth/protocols/eth/metrics.go op-geth/eth/protocols/eth/metrics.go
index 5e0aee39f84b60a211be93a7c0a5ae7d3acb838b..45c5c0699e42a01078898ab1f3787b53e034b8c3 100644
--- go-ethereum/eth/protocols/eth/metrics.go
+++ op-geth/eth/protocols/eth/metrics.go
@@ -16,7 +16,7 @@ // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
package eth
-import "github.com/ethereum/go-ethereum/metrics"
+import "github.com/tenderly/op-geth/metrics"
// meters stores ingress and egress handshake meters.
var meters bidirectionalMeters
diff --git go-ethereum/eth/protocols/eth/peer.go op-geth/eth/protocols/eth/peer.go
index ffd78b05946a88c84dcbeaf21884b128c8c7048d..e8b33a6ad24d5efebde29c02050c3d3c826df34d 100644
--- go-ethereum/eth/protocols/eth/peer.go
+++ op-geth/eth/protocols/eth/peer.go
@@ -22,10 +22,10 @@ "math/rand"
"sync"
mapset "github.com/deckarep/golang-set/v2"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/rlp"
)
const (
diff --git go-ethereum/eth/protocols/eth/protocol.go op-geth/eth/protocols/eth/protocol.go
index 47e8d97244cb280388277215d8451dbd6f68fe61..bc88d48e33c572379bb8bcbe35bccbb81eeb2f8f 100644
--- go-ethereum/eth/protocols/eth/protocol.go
+++ op-geth/eth/protocols/eth/protocol.go
@@ -22,10 +22,10 @@ "fmt"
"io"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/forkid"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/forkid"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rlp"
)
// Constants to match up protocol versions and messages
diff --git go-ethereum/eth/protocols/eth/tracker.go op-geth/eth/protocols/eth/tracker.go
index 324fd22839c4c8f9927a335e0c4d57a00fef6c7c..7806ffa5660304fd3bcb4e609284232de0891228 100644
--- go-ethereum/eth/protocols/eth/tracker.go
+++ op-geth/eth/protocols/eth/tracker.go
@@ -19,7 +19,7 @@
import (
"time"
- "github.com/ethereum/go-ethereum/p2p/tracker"
+ "github.com/tenderly/op-geth/p2p/tracker"
)
// requestTracker is a singleton tracker for eth/66 and newer request times.
diff --git go-ethereum/eth/protocols/snap/discovery.go op-geth/eth/protocols/snap/discovery.go
index 684ec7e632daf68c20094972ed660d9e443d2023..95b9cfe13a5c8b785ad801c7f65e3ef4bcd88c09 100644
--- go-ethereum/eth/protocols/snap/discovery.go
+++ op-geth/eth/protocols/snap/discovery.go
@@ -17,7 +17,7 @@
package snap
import (
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/rlp"
)
// enrEntry is the ENR entry which advertises `snap` protocol on the discovery.
diff --git go-ethereum/eth/protocols/snap/gentrie.go op-geth/eth/protocols/snap/gentrie.go
index 8ef1a007530edb7d35dbadfe3aafac13cf9f9c76..4fd184e5b54d97e49f039bb3001ae7ee6ef29e3a 100644
--- go-ethereum/eth/protocols/snap/gentrie.go
+++ op-geth/eth/protocols/snap/gentrie.go
@@ -19,10 +19,10 @@
import (
"bytes"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/trie"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/trie"
)
// genTrie interface is used by the snap syncer to generate merkle tree nodes
diff --git go-ethereum/eth/protocols/snap/metrics.go op-geth/eth/protocols/snap/metrics.go
index 25dbcc638698f503f55ed843eefeb3eddbf91cd8..537e7c573e03bfc12f4fae3a35ff77ea99beb7dc 100644
--- go-ethereum/eth/protocols/snap/metrics.go
+++ op-geth/eth/protocols/snap/metrics.go
@@ -17,7 +17,7 @@
package snap
import (
- metrics "github.com/ethereum/go-ethereum/metrics"
+ metrics "github.com/tenderly/op-geth/metrics"
)
var (
diff --git go-ethereum/eth/protocols/snap/peer.go op-geth/eth/protocols/snap/peer.go
index c57931678cec710524e4e0572eaeffcf21cfef41..4d570157919de4466e178a4aed2886dbe94b014a 100644
--- go-ethereum/eth/protocols/snap/peer.go
+++ op-geth/eth/protocols/snap/peer.go
@@ -17,9 +17,9 @@
package snap
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p"
)
// Peer is a collection of relevant information we have about a `snap` peer.
diff --git go-ethereum/eth/protocols/snap/protocol.go op-geth/eth/protocols/snap/protocol.go
index 0db206b0810ec1e56e29c1e6da6df1c9884ffdf4..64f24169bb94568e793f5abd0009331b977c30bf 100644
--- go-ethereum/eth/protocols/snap/protocol.go
+++ op-geth/eth/protocols/snap/protocol.go
@@ -20,9 +20,9 @@ import (
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rlp"
)
// Constants to match up protocol versions and messages
diff --git go-ethereum/eth/protocols/snap/range.go op-geth/eth/protocols/snap/range.go
index 8c98c71d5064207a313053b8ff101b8709e494f5..251e577702533bf953b1c303ec22b18c54b86cfb 100644
--- go-ethereum/eth/protocols/snap/range.go
+++ op-geth/eth/protocols/snap/range.go
@@ -19,8 +19,8 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/common"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
)
// hashRange is a utility to handle ranges of hashes, Split up the
diff --git go-ethereum/eth/protocols/snap/sync.go op-geth/eth/protocols/snap/sync.go
index 208d3ba3bccdc6f33157cc04079abe80fbe6855b..08ad91c5a552edbcccd774d32f97027223137e5d 100644
--- go-ethereum/eth/protocols/snap/sync.go
+++ op-geth/eth/protocols/snap/sync.go
@@ -29,19 +29,19 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/msgrate"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/msgrate"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/trie/trienode"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/eth/protocols/snap/tracker.go op-geth/eth/protocols/snap/tracker.go
index 2cf59cc23acd778e21a6beebb1ce71abacf4bb18..dedea5a80103c8cde39ebaeb57664ce01ef1678f 100644
--- go-ethereum/eth/protocols/snap/tracker.go
+++ op-geth/eth/protocols/snap/tracker.go
@@ -19,7 +19,7 @@
import (
"time"
- "github.com/ethereum/go-ethereum/p2p/tracker"
+ "github.com/tenderly/op-geth/p2p/tracker"
)
// requestTracker is a singleton tracker for request times.
diff --git go-ethereum/eth/sync.go op-geth/eth/sync.go
index cdcfbdb3db498d4b5915086ffc69bdd2d8078b82..445b848d84002fb3f9eed4aaa7807aa45891fcb1 100644
--- go-ethereum/eth/sync.go
+++ op-geth/eth/sync.go
@@ -21,12 +21,12 @@ "errors"
"math/big"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/txpool"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/txpool"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/log"
)
const (
diff --git go-ethereum/eth/tracers/internal/tracetest/util.go op-geth/eth/tracers/internal/tracetest/util.go
index 95d292c9240b07026d864f88291f6747033cedce..5ddef4a26fe3a991d8113b13befa79b40813589c 100644
--- go-ethereum/eth/tracers/internal/tracetest/util.go
+++ op-geth/eth/tracers/internal/tracetest/util.go
@@ -5,8 +5,8 @@ "strings"
"unicode"
// Force-load native and js packages, to trigger registration
- _ "github.com/ethereum/go-ethereum/eth/tracers/js"
- _ "github.com/ethereum/go-ethereum/eth/tracers/native"
+ _ "github.com/tenderly/op-geth/eth/tracers/js"
+ _ "github.com/tenderly/op-geth/eth/tracers/native"
)
// To generate a new callTracer test, copy paste the makeTest method below into
diff --git go-ethereum/eth/tracers/js/goja.go op-geth/eth/tracers/js/goja.go
index 07c138bae47b9da568bd454f92feef14c773b0dd..0c5b92b37658af7338a5e5946280fc72d36c7ee9 100644
--- go-ethereum/eth/tracers/js/goja.go
+++ op-geth/eth/tracers/js/goja.go
@@ -24,12 +24,12 @@ "math/big"
"github.com/dop251/goja"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/tracers"
- jsassets "github.com/ethereum/go-ethereum/eth/tracers/js/internal/tracers"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/tracers"
+ jsassets "github.com/tenderly/op-geth/eth/tracers/js/internal/tracers"
)
var assetTracers = make(map[string]string)
diff --git go-ethereum/eth/tracers/logger/access_list_tracer.go op-geth/eth/tracers/logger/access_list_tracer.go
index 766ee4e4b95c41231414119e23940f30a04aa1fd..7e285a32dcbae8f050da9eec7b6bb17f8bb4302b 100644
--- go-ethereum/eth/tracers/logger/access_list_tracer.go
+++ op-geth/eth/tracers/logger/access_list_tracer.go
@@ -19,9 +19,9 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
)
// accessList is an accumulator for the set of accounts and storage slots an EVM
diff --git go-ethereum/eth/tracers/logger/gen_structlog.go op-geth/eth/tracers/logger/gen_structlog.go
index b406cb344546bbdf51118b83fb726bf8e01c847b..83a74189c05fb30b2938afb1270bb8f7406858de 100644
--- go-ethereum/eth/tracers/logger/gen_structlog.go
+++ op-geth/eth/tracers/logger/gen_structlog.go
@@ -5,10 +5,10 @@
import (
"encoding/json"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/vm"
"github.com/holiman/uint256"
)
diff --git go-ethereum/eth/tracers/logger/logger.go op-geth/eth/tracers/logger/logger.go
index 2b36f9f4922f6989f3f64afd126c57af2e1ac707..4f698acd82d16b089e319dd8632a70f494f191f2 100644
--- go-ethereum/eth/tracers/logger/logger.go
+++ op-geth/eth/tracers/logger/logger.go
@@ -25,13 +25,13 @@ "math/big"
"strings"
"sync/atomic"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/params"
)
// Storage represents a contract's storage.
diff --git go-ethereum/eth/tracers/logger/logger_json.go op-geth/eth/tracers/logger/logger_json.go
index a2cb4cd9fc598422aa22ce3e00144c4c9c0d9971..d15a57d966e5412f7e5b3432e4eb66839d6a157f 100644
--- go-ethereum/eth/tracers/logger/logger_json.go
+++ op-geth/eth/tracers/logger/logger_json.go
@@ -21,9 +21,9 @@ "encoding/json"
"io"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/vm"
)
type JSONLogger struct {
diff --git go-ethereum/eth/tracers/native/4byte.go op-geth/eth/tracers/native/4byte.go
index 5a2c4f91115f72eb57b9fbb4fb6ac0fd93653e7c..645d69bb69bfe2a67e0733a022d2a6da03782645 100644
--- go-ethereum/eth/tracers/native/4byte.go
+++ op-geth/eth/tracers/native/4byte.go
@@ -22,9 +22,9 @@ "math/big"
"strconv"
"sync/atomic"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
)
func init() {
diff --git go-ethereum/eth/tracers/native/call.go op-geth/eth/tracers/native/call.go
index be9b58a4cd3c384e823eea19b52a3de6cb9cf366..d1e16a793964491d9710d7808c4d77a9b00b138f 100644
--- go-ethereum/eth/tracers/native/call.go
+++ op-geth/eth/tracers/native/call.go
@@ -22,12 +22,12 @@ "errors"
"math/big"
"sync/atomic"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/accounts/abi"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/log"
)
//go:generate go run github.com/fjl/gencodec -type callFrame -field-override callFrameMarshaling -out gen_callframe_json.go
@@ -41,7 +41,7 @@ Address common.Address `json:"address"`
Topics []common.Hash `json:"topics"`
Data hexutil.Bytes `json:"data"`
// Position of the log relative to subcalls within the same trace
- // See https://github.com/ethereum/go-ethereum/pull/28389 for details
+ // See https://github.com/tenderly/op-geth/pull/28389 for details
Position hexutil.Uint `json:"position"`
}
@@ -260,6 +260,10 @@ // error arising from the encoding or forceful termination (via `Stop`).
func (t *callTracer) GetResult() (json.RawMessage, error) {
if len(t.callstack) != 1 {
return nil, errors.New("incorrect number of top-level calls")
+ }
+
+ if t.callstack[0].Type == vm.STOP {
+ t.callstack[0].Error = "failed deposit transaction"
}
res, err := json.Marshal(t.callstack[0])
diff --git go-ethereum/eth/tracers/native/call_flat.go op-geth/eth/tracers/native/call_flat.go
index 266ab9900146ca413600888e0238e4c5a3102b77..ac3f42de2bfb1331fbdadf15b6a97c8a7d23dd1b 100644
--- go-ethereum/eth/tracers/native/call_flat.go
+++ op-geth/eth/tracers/native/call_flat.go
@@ -23,10 +23,10 @@ "fmt"
"math/big"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
)
//go:generate go run github.com/fjl/gencodec -type flatCallAction -field-override flatCallActionMarshaling -out gen_flatcallaction_json.go
@@ -215,6 +215,10 @@ if len(t.tracer.callstack) < 1 {
return nil, errors.New("invalid number of calls")
}
+ if t.tracer.callstack[0].Type == vm.STOP {
+ t.tracer.callstack[0].Error = "failed deposit transaction"
+ }
+
flat, err := flatFromNested(&t.tracer.callstack[0], []int{}, t.config.ConvertParityErrors, t.ctx)
if err != nil {
return nil, err
@@ -249,7 +253,7 @@ case vm.CREATE, vm.CREATE2:
frame = newFlatCreate(input)
case vm.SELFDESTRUCT:
frame = newFlatSelfdestruct(input)
- case vm.CALL, vm.STATICCALL, vm.CALLCODE, vm.DELEGATECALL:
+ case vm.CALL, vm.STATICCALL, vm.CALLCODE, vm.DELEGATECALL, vm.STOP:
frame = newFlatCall(input)
default:
return nil, fmt.Errorf("unrecognized call frame type: %s", input.Type)
diff --git go-ethereum/eth/tracers/native/gen_account_json.go op-geth/eth/tracers/native/gen_account_json.go
index 4c39cbc38cd4ffdca09230849426d360ca6fddc7..8d3453fe84b9f5e378c8eb67cff27413fd895cc2 100644
--- go-ethereum/eth/tracers/native/gen_account_json.go
+++ op-geth/eth/tracers/native/gen_account_json.go
@@ -6,8 +6,8 @@ import (
"encoding/json"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var _ = (*accountMarshaling)(nil)
diff --git go-ethereum/eth/tracers/native/gen_callframe_json.go op-geth/eth/tracers/native/gen_callframe_json.go
index c44f38390df7b3df171b85352b00d916e78a9b75..53f9269fdb27a5216bea4ec1023cbbc609cb8c50 100644
--- go-ethereum/eth/tracers/native/gen_callframe_json.go
+++ op-geth/eth/tracers/native/gen_callframe_json.go
@@ -6,9 +6,9 @@ import (
"encoding/json"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/vm"
)
var _ = (*callFrameMarshaling)(nil)
diff --git go-ethereum/eth/tracers/native/gen_flatcallaction_json.go op-geth/eth/tracers/native/gen_flatcallaction_json.go
index c0756069835bdd3c8b6de4b271de7ac978f8a13b..e6b3eea33a36e2060224a9a3402f85cb9c344d2a 100644
--- go-ethereum/eth/tracers/native/gen_flatcallaction_json.go
+++ op-geth/eth/tracers/native/gen_flatcallaction_json.go
@@ -6,8 +6,8 @@ import (
"encoding/json"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var _ = (*flatCallActionMarshaling)(nil)
diff --git go-ethereum/eth/tracers/native/gen_flatcallresult_json.go op-geth/eth/tracers/native/gen_flatcallresult_json.go
index e9fa5e44da8bc63e577ded1786883197a3e7c41c..588f0ec12ef366942aa48303875655d402370231 100644
--- go-ethereum/eth/tracers/native/gen_flatcallresult_json.go
+++ op-geth/eth/tracers/native/gen_flatcallresult_json.go
@@ -5,8 +5,8 @@
import (
"encoding/json"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var _ = (*flatCallResultMarshaling)(nil)
diff --git go-ethereum/eth/tracers/native/mux.go op-geth/eth/tracers/native/mux.go
index db8ddd64380db9301ed73f55a0ff361505a20467..11cd9db162e1decdb2f325af172a8b27511abb49 100644
--- go-ethereum/eth/tracers/native/mux.go
+++ op-geth/eth/tracers/native/mux.go
@@ -20,9 +20,9 @@ import (
"encoding/json"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
)
func init() {
diff --git go-ethereum/eth/tracers/native/noop.go op-geth/eth/tracers/native/noop.go
index 3beecd8abfed7dbc146837d9a13934a2b0184f12..3fd1bd62b2e892ce1fa5256fbc2b97616f7f7216 100644
--- go-ethereum/eth/tracers/native/noop.go
+++ op-geth/eth/tracers/native/noop.go
@@ -20,9 +20,9 @@ import (
"encoding/json"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/eth/tracers"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/eth/tracers"
)
func init() {
diff --git go-ethereum/eth/tracers/native/prestate.go op-geth/eth/tracers/native/prestate.go
index d7e10173cf278ad8f1a7d917d5b2030ec280ae6d..86f865156c96a3f746b7bd4d80e5c85777cfde99 100644
--- go-ethereum/eth/tracers/native/prestate.go
+++ op-geth/eth/tracers/native/prestate.go
@@ -22,12 +22,12 @@ "encoding/json"
"math/big"
"sync/atomic"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/tracers"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth/tracers"
+ "github.com/tenderly/op-geth/log"
)
//go:generate go run github.com/fjl/gencodec -type account -field-override accountMarshaling -out gen_account_json.go
diff --git go-ethereum/eth/tracers/tracers.go op-geth/eth/tracers/tracers.go
index 7b43b7cf834a838028a63770d8534692589b1800..a695a8505494d921ec455e8618eadab1829e018d 100644
--- go-ethereum/eth/tracers/tracers.go
+++ op-geth/eth/tracers/tracers.go
@@ -23,8 +23,8 @@ "errors"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/vm"
)
// Context contains some contextual infos for a transaction execution that is not
diff --git go-ethereum/ethclient/ethclient.go op-geth/ethclient/ethclient.go
index 5c3cb79dd65c80d220a2b3c4ff1d5e1a00f10cda..2d309862a48a38c13c87f3ee867ae7e08b79cafb 100644
--- go-ethereum/ethclient/ethclient.go
+++ op-geth/ethclient/ethclient.go
@@ -24,11 +24,11 @@ "errors"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rpc"
)
// Client defines typed wrappers for the Ethereum RPC API.
diff --git go-ethereum/ethclient/gethclient/gethclient.go op-geth/ethclient/gethclient/gethclient.go
index 73d05d499efe91bb0de8d594cc18f49603790c77..d06bcbb70abacffd8f4d7ec11f64b2d5a46bbce9 100644
--- go-ethereum/ethclient/gethclient/gethclient.go
+++ op-geth/ethclient/gethclient/gethclient.go
@@ -25,12 +25,12 @@ "math/big"
"runtime"
"runtime/debug"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/rpc"
)
// Client is a wrapper around rpc.Client that implements geth-specific functionality.
diff --git go-ethereum/ethclient/signer.go op-geth/ethclient/signer.go
index f827d4eb56f439bbc286fa73b47842ad04d75e34..fe8ec7a04a3d3781b29c51fa4179508c4e40b4f4 100644
--- go-ethereum/ethclient/signer.go
+++ op-geth/ethclient/signer.go
@@ -20,8 +20,8 @@ import (
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
)
// senderFromServer is a types.Signer that remembers the sender address returned by the RPC
diff --git go-ethereum/ethclient/simulated/options.go op-geth/ethclient/simulated/options.go
index 6db995c917520104d26bf177762fa36784043181..49d6573d04e44dad6dd76f7799fe131615774dd5 100644
--- go-ethereum/ethclient/simulated/options.go
+++ op-geth/ethclient/simulated/options.go
@@ -19,8 +19,8 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/node"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/node"
)
// WithBlockGasLimit configures the simulated backend to target a specific gas limit
diff --git go-ethereum/ethdb/dbtest/testsuite.go op-geth/ethdb/dbtest/testsuite.go
index 29bd24364e3f7408579abe61ac7bb8da9a178e91..1c375f9258a93afe6b0688849370a2060ecd0f6e 100644
--- go-ethereum/ethdb/dbtest/testsuite.go
+++ op-geth/ethdb/dbtest/testsuite.go
@@ -23,7 +23,7 @@ "reflect"
"sort"
"testing"
- "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/tenderly/op-geth/ethdb"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/ethdb/leveldb/leveldb.go op-geth/ethdb/leveldb/leveldb.go
index e58efbddbe80eb271c706db78f52672db4411cf8..0b31ace19f46346e450ca76433d914a5c3860581 100644
--- go-ethereum/ethdb/leveldb/leveldb.go
+++ op-geth/ethdb/leveldb/leveldb.go
@@ -26,15 +26,15 @@ "strings"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
"github.com/syndtr/goleveldb/leveldb"
"github.com/syndtr/goleveldb/leveldb/errors"
"github.com/syndtr/goleveldb/leveldb/filter"
"github.com/syndtr/goleveldb/leveldb/opt"
"github.com/syndtr/goleveldb/leveldb/util"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
const (
diff --git go-ethereum/ethdb/memorydb/memorydb.go op-geth/ethdb/memorydb/memorydb.go
index 2a939f9a1850968fac1fae47ea63dc884bff0ff8..63dbee53fbbf392230db4601daf98e75e10c7952 100644
--- go-ethereum/ethdb/memorydb/memorydb.go
+++ op-geth/ethdb/memorydb/memorydb.go
@@ -23,8 +23,8 @@ "sort"
"strings"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
)
var (
diff --git go-ethereum/ethdb/pebble/pebble.go op-geth/ethdb/pebble/pebble.go
index af4686cf5b72ae552c1f8f475907dc293355531d..1d6505f2b61f1859e6734079eea1fb2861e87ac5 100644
--- go-ethereum/ethdb/pebble/pebble.go
+++ op-geth/ethdb/pebble/pebble.go
@@ -27,10 +27,10 @@ "time"
"github.com/cockroachdb/pebble"
"github.com/cockroachdb/pebble/bloom"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
const (
@@ -220,7 +220,7 @@ WriteStallEnd: db.onWriteStallEnd,
},
Logger: panicLogger{}, // TODO(karalabe): Delete when this is upstreamed in Pebble
}
- // Disable seek compaction explicitly. Check https://github.com/ethereum/go-ethereum/pull/20130
+ // Disable seek compaction explicitly. Check https://github.com/tenderly/op-geth/pull/20130
// for more details.
opt.Experimental.ReadSamplingMultiplier = -1
diff --git go-ethereum/ethdb/remotedb/remotedb.go op-geth/ethdb/remotedb/remotedb.go
index c1c803caf2b907b7eb03180f0a9f5ca82cea4575..5384366232cd6e5495db0aa812ac08256268fcd1 100644
--- go-ethereum/ethdb/remotedb/remotedb.go
+++ op-geth/ethdb/remotedb/remotedb.go
@@ -22,9 +22,9 @@ // exclusive access, but it can be used for basic diagnostics of a remote node.
package remotedb
import (
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/rpc"
)
// Database is a key-value lookup for a remote database via debug_dbGet.
diff --git go-ethereum/ethstats/ethstats.go op-geth/ethstats/ethstats.go
index 61ceec443ebccc3337a898a725906748235fd570..2f2350dfd4f7a5fb9a4dd077f8c072ba88305a80 100644
--- go-ethereum/ethstats/ethstats.go
+++ op-geth/ethstats/ethstats.go
@@ -30,20 +30,20 @@ "strings"
"sync"
"time"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/consensus"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- ethproto "github.com/ethereum/go-ethereum/eth/protocols/eth"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/miner"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/gorilla/websocket"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/consensus"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ ethproto "github.com/tenderly/op-geth/eth/protocols/eth"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/miner"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/rpc"
)
const (
diff --git go-ethereum/event/subscription.go op-geth/event/subscription.go
index 07e059c6db30b846d5b561a9cfd2d4914139009f..db2d385b9bf16cf9867c08f5c6a4d8eb72262d9e 100644
--- go-ethereum/event/subscription.go
+++ op-geth/event/subscription.go
@@ -21,7 +21,7 @@ "context"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
+ "github.com/tenderly/op-geth/common/mclock"
)
// Subscription represents a stream of events. The carrier of the events is typically a
diff --git go-ethereum/graphql/graphiql.go op-geth/graphql/graphiql.go
index 823df0c64191e746d78e189f7f8d09294117269d..906728e8d179ced1f47827d9161ab388458b4199 100644
--- go-ethereum/graphql/graphiql.go
+++ op-geth/graphql/graphiql.go
@@ -27,8 +27,8 @@ "encoding/json"
"net/http"
"path/filepath"
- "github.com/ethereum/go-ethereum/graphql/internal/graphiql"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/graphql/internal/graphiql"
+ "github.com/tenderly/op-geth/log"
)
// GraphiQL is an in-browser IDE for exploring GraphiQL APIs.
diff --git go-ethereum/graphql/graphql.go op-geth/graphql/graphql.go
index bac86476b10532037855f92d8196e350700e9440..311182c27600c61229bebd90863761877dadab20 100644
--- go-ethereum/graphql/graphql.go
+++ op-geth/graphql/graphql.go
@@ -27,17 +27,17 @@ "strconv"
"strings"
"sync"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/filters"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus/misc/eip1559"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/filters"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/rpc"
)
var (
@@ -773,7 +773,7 @@ if !chaincfg.IsLondon(new(big.Int).Add(header.Number, common.Big1)) {
return nil, nil
}
}
- nextBaseFee := eip1559.CalcBaseFee(chaincfg, header)
+ nextBaseFee := eip1559.CalcBaseFee(chaincfg, header, header.Time+1)
return (*hexutil.Big)(nextBaseFee), nil
}
diff --git go-ethereum/graphql/service.go op-geth/graphql/service.go
index 584165bdb802e06c09a7994e8349be4b5c8f70f5..cc9104f8e44082312ed5f26796e812215b7728e6 100644
--- go-ethereum/graphql/service.go
+++ op-geth/graphql/service.go
@@ -24,12 +24,12 @@ "strconv"
"sync"
"time"
- "github.com/ethereum/go-ethereum/eth/filters"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/graph-gophers/graphql-go"
gqlErrors "github.com/graph-gophers/graphql-go/errors"
+ "github.com/tenderly/op-geth/eth/filters"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/rpc"
)
type handler struct {
diff --git go-ethereum/interfaces.go op-geth/interfaces.go
index 53e2e3ae169d597e9b04ba20e1f9f5f9bbbecd8e..dab793b475263b877880e7947493ef3efb321cb7 100644
--- go-ethereum/interfaces.go
+++ op-geth/interfaces.go
@@ -22,8 +22,8 @@ "context"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
)
// NotFound is returned by API methods if the requested item does not exist.
diff --git go-ethereum/internal/blocktest/test_hash.go op-geth/internal/blocktest/test_hash.go
index 4d2b077e89b56023995684cf5194dfd75090b154..7172a5f6a653e37a63205614a474ccf8c4cb899d 100644
--- go-ethereum/internal/blocktest/test_hash.go
+++ op-geth/internal/blocktest/test_hash.go
@@ -25,7 +25,7 @@
import (
"hash"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/internal/build/env.go op-geth/internal/build/env.go
index 0854fba2498d2f490ca5de1e73c1c9f2c58932a3..6a621495ba5441adbc045f1210f1f75c98a969b0 100644
--- go-ethereum/internal/build/env.go
+++ op-geth/internal/build/env.go
@@ -102,6 +102,10 @@ func LocalEnv() Environment {
env := applyEnvFlags(Environment{Name: "local", Repo: "ethereum/go-ethereum"})
head := readGitFile("HEAD")
+ if info, err := os.Stat(".git/objects"); err == nil && info.IsDir() && env.Tag == "" {
+ env.Tag = firstLine(RunGit("tag", "-l", "--points-at", "HEAD"))
+ }
+
if fields := strings.Fields(head); len(fields) == 2 {
head = fields[1]
} else {
@@ -111,6 +115,7 @@ // Additional check required to verify, that file contains commit hash
commitRe, _ := regexp.Compile("^([0-9a-f]{40})$")
if commit := commitRe.FindString(head); commit != "" && env.Commit == "" {
env.Commit = commit
+ env.Date = getDate(env.Commit)
}
return env
}
@@ -122,9 +127,6 @@ if env.Branch == "" {
if head != "HEAD" {
env.Branch = strings.TrimPrefix(head, "refs/heads/")
}
- }
- if info, err := os.Stat(".git/objects"); err == nil && info.IsDir() && env.Tag == "" {
- env.Tag = firstLine(RunGit("tag", "-l", "--points-at", "HEAD"))
}
return env
}
diff --git go-ethereum/internal/cmdtest/test_cmd.go op-geth/internal/cmdtest/test_cmd.go
index 4890d0b7c61733450b3170c1ca50bfcdd44cad1c..63f8a73724e3d0a856d9cffb4ac1e7ccd5f7893b 100644
--- go-ethereum/internal/cmdtest/test_cmd.go
+++ op-geth/internal/cmdtest/test_cmd.go
@@ -32,7 +32,7 @@ "testing"
"text/template"
"time"
- "github.com/ethereum/go-ethereum/internal/reexec"
+ "github.com/tenderly/op-geth/internal/reexec"
)
func NewTestCmd(t *testing.T, data interface{}) *TestCmd {
diff --git go-ethereum/internal/debug/api.go op-geth/internal/debug/api.go
index 482989e0d0f34d7951c6dfeb61d9caf726ab5be5..7567324043bca205ee12a644049d46bf408bfb5e 100644
--- go-ethereum/internal/debug/api.go
+++ op-geth/internal/debug/api.go
@@ -35,8 +35,8 @@ "strings"
"sync"
"time"
- "github.com/ethereum/go-ethereum/log"
"github.com/hashicorp/go-bexpr"
+ "github.com/tenderly/op-geth/log"
"golang.org/x/exp/slog"
)
diff --git go-ethereum/internal/debug/flags.go op-geth/internal/debug/flags.go
index dac878a7b1ffc087fd08154516ac58c8ed1aa516..101c69d9abd624bc1d76fa298fd57e03a53a476f 100644
--- go-ethereum/internal/debug/flags.go
+++ op-geth/internal/debug/flags.go
@@ -26,13 +26,13 @@ "os"
"path/filepath"
"runtime"
- "github.com/ethereum/go-ethereum/internal/flags"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/metrics/exp"
"github.com/fjl/memsize/memsizeui"
"github.com/mattn/go-colorable"
"github.com/mattn/go-isatty"
+ "github.com/tenderly/op-geth/internal/flags"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/metrics/exp"
"github.com/urfave/cli/v2"
"golang.org/x/exp/slog"
"gopkg.in/natefinch/lumberjack.v2"
diff --git go-ethereum/internal/debug/trace.go op-geth/internal/debug/trace.go
index e291030b82e32bac23eaa1579add8350cb50c853..6ec5e192c545040afe67b4bc73b65a2e513ee5e6 100644
--- go-ethereum/internal/debug/trace.go
+++ op-geth/internal/debug/trace.go
@@ -21,7 +21,7 @@ "errors"
"os"
"runtime/trace"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
// StartGoTrace turns on tracing, writing to the given file.
diff --git go-ethereum/internal/era/accumulator.go op-geth/internal/era/accumulator.go
index 19e03973f1f51c9bcecb7eb3b38181b3849df6be..e78d644139745afa809f3df830e3f1821728a844 100644
--- go-ethereum/internal/era/accumulator.go
+++ op-geth/internal/era/accumulator.go
@@ -20,8 +20,8 @@ import (
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
ssz "github.com/ferranbt/fastssz"
+ "github.com/tenderly/op-geth/common"
)
// ComputeAccumulator calculates the SSZ hash tree root of the Era1
diff --git go-ethereum/internal/era/builder.go op-geth/internal/era/builder.go
index 9217c049f33bc6cadf66c4fde12618bb6ba98be6..c3457a472f244c35178e459b249269322f948c66 100644
--- go-ethereum/internal/era/builder.go
+++ op-geth/internal/era/builder.go
@@ -22,11 +22,11 @@ "fmt"
"io"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/internal/era/e2store"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/golang/snappy"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/internal/era/e2store"
+ "github.com/tenderly/op-geth/rlp"
)
// Builder is used to create Era1 archives of block data.
diff --git go-ethereum/internal/era/era.go op-geth/internal/era/era.go
index a0e701b7e0f920b8b1be5e2ebec70502014ff7b9..8bc80196f6d97c48cc4c480a07c55e3a8b328df3 100644
--- go-ethereum/internal/era/era.go
+++ op-geth/internal/era/era.go
@@ -27,11 +27,11 @@ "strconv"
"strings"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/internal/era/e2store"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/golang/snappy"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/internal/era/e2store"
+ "github.com/tenderly/op-geth/rlp"
)
var (
diff --git go-ethereum/internal/era/iterator.go op-geth/internal/era/iterator.go
index e74a8154b1a63f58ac82e04b9584080a8a6c6505..d51510654a4ff5cc835c499e8c00fd417ddae3cd 100644
--- go-ethereum/internal/era/iterator.go
+++ op-geth/internal/era/iterator.go
@@ -21,8 +21,8 @@ "fmt"
"io"
"math/big"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rlp"
)
// Iterator wraps RawIterator and returns decoded Era1 entries.
diff --git go-ethereum/internal/ethapi/addrlock.go op-geth/internal/ethapi/addrlock.go
index 61ddff688cccf48bce3b2f5c7f51f1557d1a2117..2dd219d2d41258345dc40b1942dc0465481dc419 100644
--- go-ethereum/internal/ethapi/addrlock.go
+++ op-geth/internal/ethapi/addrlock.go
@@ -19,7 +19,7 @@
import (
"sync"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
type AddrLocker struct {
diff --git go-ethereum/internal/ethapi/dbapi.go op-geth/internal/ethapi/dbapi.go
index 33fda936dcd0fd832125039668a8f26a54c27825..4ba48820752ace13ccb0bc7a335fd40ab21454b8 100644
--- go-ethereum/internal/ethapi/dbapi.go
+++ op-geth/internal/ethapi/dbapi.go
@@ -17,8 +17,8 @@
package ethapi
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
// DbGet returns the raw value of a key stored in the database.
diff --git go-ethereum/internal/ethapi/errors.go op-geth/internal/ethapi/errors.go
index b5e668a8050a2429e69ef25d8e232be1179b3efb..41f2972263b891f6626b349c5c0958e903308e3c 100644
--- go-ethereum/internal/ethapi/errors.go
+++ op-geth/internal/ethapi/errors.go
@@ -19,9 +19,9 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/tenderly/op-geth/accounts/abi"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/vm"
)
// revertError is an API error that encompasses an EVM revert with JSON error
diff --git go-ethereum/internal/ethapi/transaction_args.go op-geth/internal/ethapi/transaction_args.go
index bae1c68641594887b4a800c0f7bfd6af58326ecf..54c9ab2e94d89d4a9b0c89aa817024551b31d564 100644
--- go-ethereum/internal/ethapi/transaction_args.go
+++ op-geth/internal/ethapi/transaction_args.go
@@ -24,17 +24,17 @@ "errors"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto/kzg4844"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto/kzg4844"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rpc"
)
var (
@@ -55,7 +55,7 @@ Nonce *hexutil.Uint64 `json:"nonce"`
// We accept "data" and "input" for backwards-compatibility reasons.
// "input" is the newer name and should be preferred by clients.
- // Issue detail: https://github.com/ethereum/go-ethereum/issues/15628
+ // Issue detail: https://github.com/tenderly/op-geth/issues/15628
Data *hexutil.Bytes `json:"data"`
Input *hexutil.Bytes `json:"input"`
@@ -198,7 +198,7 @@ return errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
}
// If the tx has completely specified a fee mechanism, no default is needed.
// This allows users who are not yet synced past London to get defaults for
- // other tx values. See https://github.com/ethereum/go-ethereum/pull/23274
+ // other tx values. See https://github.com/tenderly/op-geth/pull/23274
// for more information.
eip1559ParamsSet := args.MaxFeePerGas != nil && args.MaxPriorityFeePerGas != nil
// Sanity check the EIP-1559 fee parameters if present.
diff --git go-ethereum/internal/flags/flags.go op-geth/internal/flags/flags.go
index bf62c53adf5b8227560af71bd0655fef7a124085..24402b9713ec844e98ac154457179a6dcb184e3e 100644
--- go-ethereum/internal/flags/flags.go
+++ op-geth/internal/flags/flags.go
@@ -28,7 +28,7 @@ "path/filepath"
"strings"
"syscall"
- "github.com/ethereum/go-ethereum/common/math"
+ "github.com/tenderly/op-geth/common/math"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/internal/flags/helpers.go op-geth/internal/flags/helpers.go
index 0112724fa145ae33c3a8ca33b426f0d63a608390..e939a803ec03d1722c868f8eb8634ca4e11ba48a 100644
--- go-ethereum/internal/flags/helpers.go
+++ op-geth/internal/flags/helpers.go
@@ -23,10 +23,10 @@ "regexp"
"sort"
"strings"
- "github.com/ethereum/go-ethereum/internal/version"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
"github.com/mattn/go-isatty"
+ "github.com/tenderly/op-geth/internal/version"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
"github.com/urfave/cli/v2"
)
diff --git go-ethereum/internal/jsre/deps/web3.js op-geth/internal/jsre/deps/web3.js
index 0b360e74150a3784edb9115ffdbbbb906b546ee6..1c01bfc237af351123a11c48ee5f47734b88764e 100644
--- go-ethereum/internal/jsre/deps/web3.js
+++ op-geth/internal/jsre/deps/web3.js
@@ -5882,7 +5882,7 @@ * @file bzz.js
* @author Alex Beregszaszi <alex@rtfs.hu>
* @date 2016
*
- * Reference: https://github.com/ethereum/go-ethereum/blob/swarm/internal/web3ext/web3ext.go#L33
+ * Reference: https://github.com/tenderly/op-geth/blob/swarm/internal/web3ext/web3ext.go#L33
*/
"use strict";
diff --git go-ethereum/internal/jsre/jsre.go op-geth/internal/jsre/jsre.go
index f6e21d2ef7016b18e208460e80d3d7afbb86321b..a097e34eecb2b71fa0f11b459c99466fffbbf521 100644
--- go-ethereum/internal/jsre/jsre.go
+++ op-geth/internal/jsre/jsre.go
@@ -28,7 +28,7 @@ "os"
"time"
"github.com/dop251/goja"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// JSRE is a JS runtime environment embedding the goja interpreter.
diff --git go-ethereum/internal/shutdowncheck/shutdown_tracker.go op-geth/internal/shutdowncheck/shutdown_tracker.go
index c95b4f02f4b022cd99dfb509b0cd2a8a8c3a1aa0..9ff06b227305d4ec7837ea3e81840f4417dae0c5 100644
--- go-ethereum/internal/shutdowncheck/shutdown_tracker.go
+++ op-geth/internal/shutdowncheck/shutdown_tracker.go
@@ -19,10 +19,10 @@
import (
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
)
// ShutdownTracker is a service that reports previous unclean shutdowns
diff --git go-ethereum/internal/testlog/testlog.go op-geth/internal/testlog/testlog.go
index 037b7ee9c1206f56203745a224d36abbff3f08f8..19b2e429aa1674046892c1c8721ced73c0ab7626 100644
--- go-ethereum/internal/testlog/testlog.go
+++ op-geth/internal/testlog/testlog.go
@@ -24,7 +24,7 @@ "fmt"
"sync"
"testing"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
"golang.org/x/exp/slog"
)
@@ -96,6 +96,10 @@ l: log.NewLogger(handler),
mu: new(sync.Mutex),
h: &bh,
}
+}
+
+func (l *logger) Handler() slog.Handler {
+ return l.l.Handler()
}
func (l *logger) Write(level slog.Level, msg string, ctx ...interface{}) {}
diff --git go-ethereum/internal/testrand/rand.go op-geth/internal/testrand/rand.go
index 690993de05b92df7762199911b3efe006f2f15a1..f6ea17a9c166de750b21556643acc2b39d4a1ec8 100644
--- go-ethereum/internal/testrand/rand.go
+++ op-geth/internal/testrand/rand.go
@@ -21,7 +21,7 @@ crand "crypto/rand"
"encoding/binary"
mrand "math/rand"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// prng is a pseudo random number generator seeded by strong randomness.
diff --git go-ethereum/internal/version/version.go op-geth/internal/version/version.go
index 0daea02b57e507e5cc45e9cbd29447422fd30851..54c21a16a009bb3e998b20165e6b12d904cf8342 100644
--- go-ethereum/internal/version/version.go
+++ op-geth/internal/version/version.go
@@ -23,10 +23,10 @@ "runtime"
"runtime/debug"
"strings"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/params"
)
-const ourPath = "github.com/ethereum/go-ethereum" // Path to our module
+const ourPath = "github.com/tenderly/op-geth" // Path to our module
// These variables are set at build-time by the linker when the build is
// done by build/ci.go.
diff --git go-ethereum/log/handler.go op-geth/log/handler.go
index 7459aad8913b29a491cfa45d1b6ab524dc9c7617..256b57f2d0b2e46e289a3c3d97896113b0672634 100644
--- go-ethereum/log/handler.go
+++ op-geth/log/handler.go
@@ -117,6 +117,7 @@ // JSONHandler returns a handler which prints records in JSON format.
func JSONHandler(wr io.Writer) slog.Handler {
return slog.NewJSONHandler(wr, &slog.HandlerOptions{
ReplaceAttr: builtinReplaceJSON,
+ Level: &leveler{levelMaxVerbosity},
})
}
diff --git go-ethereum/log/logger.go op-geth/log/logger.go
index 75e3643044889295b9076d8c20173b55d4fa7ef4..c28bbde56840e40cf18ca2e364fcbdec8d23847d 100644
--- go-ethereum/log/logger.go
+++ op-geth/log/logger.go
@@ -137,6 +137,9 @@ Write(level slog.Level, msg string, attrs ...any)
// Enabled reports whether l emits log records at the given context and level.
Enabled(ctx context.Context, level slog.Level) bool
+
+ // Handler returns the underlying handler of the inner logger.
+ Handler() slog.Handler
}
type logger struct {
@@ -148,6 +151,10 @@ func NewLogger(h slog.Handler) Logger {
return &logger{
slog.New(h),
}
+}
+
+func (l *logger) Handler() slog.Handler {
+ return l.inner.Handler()
}
// write logs a message at the specified level:
diff --git go-ethereum/metrics/cpu_enabled.go op-geth/metrics/cpu_enabled.go
index 2359028a2120d88c7f4833139d139de07c36deb6..c53952f27452bab595f653d117d15d3b0369d078 100644
--- go-ethereum/metrics/cpu_enabled.go
+++ op-geth/metrics/cpu_enabled.go
@@ -20,8 +20,8 @@
package metrics
import (
- "github.com/ethereum/go-ethereum/log"
"github.com/shirou/gopsutil/cpu"
+ "github.com/tenderly/op-geth/log"
)
// ReadCPUStats retrieves the current CPU stats.
diff --git go-ethereum/metrics/cputime_unix.go op-geth/metrics/cputime_unix.go
index ad4f812fd285da1b46cf15552ff65005bcff77a9..0c4d365ad1beb4343920dc9c3d5ac8e6a5899069 100644
--- go-ethereum/metrics/cputime_unix.go
+++ op-geth/metrics/cputime_unix.go
@@ -22,7 +22,7 @@
import (
syscall "golang.org/x/sys/unix"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
// getProcessCPUTime retrieves the process' CPU time since program startup.
diff --git go-ethereum/metrics/exp/exp.go op-geth/metrics/exp/exp.go
index 7e3f82a075fc3e384478350fae012dc4d128297c..2b8446f5b5727bb8969949e4bc438744b2e984eb 100644
--- go-ethereum/metrics/exp/exp.go
+++ op-geth/metrics/exp/exp.go
@@ -8,9 +8,9 @@ "fmt"
"net/http"
"sync"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/metrics/prometheus"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/metrics/prometheus"
)
type exp struct {
diff --git go-ethereum/metrics/influxdb/influxdb.go op-geth/metrics/influxdb/influxdb.go
index bbc4fc024b34fe6df61f64871a42efa2e7ffdab7..26e088f7886dbdb7d2ac1c659858ee4ba4a54d36 100644
--- go-ethereum/metrics/influxdb/influxdb.go
+++ op-geth/metrics/influxdb/influxdb.go
@@ -3,7 +3,7 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/metrics"
)
func readMeter(namespace, name string, i interface{}) (string, map[string]interface{}) {
diff --git go-ethereum/metrics/influxdb/influxdbv1.go op-geth/metrics/influxdb/influxdbv1.go
index ac58280803bb16eb425538fee57f073f829661a2..33c528f55c9860fc68b6c038b61540afa8c4b2e1 100644
--- go-ethereum/metrics/influxdb/influxdbv1.go
+++ op-geth/metrics/influxdb/influxdbv1.go
@@ -5,9 +5,9 @@ "fmt"
uurl "net/url"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
client "github.com/influxdata/influxdb1-client/v2"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
type reporter struct {
diff --git go-ethereum/metrics/influxdb/influxdbv2.go op-geth/metrics/influxdb/influxdbv2.go
index 114d57ae076eb5b2fa53f43605874128e6299809..9b9c359dc5f9210693edecadf0c248b52eeca18a 100644
--- go-ethereum/metrics/influxdb/influxdbv2.go
+++ op-geth/metrics/influxdb/influxdbv2.go
@@ -4,10 +4,10 @@ import (
"context"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
influxdb2 "github.com/influxdata/influxdb-client-go/v2"
"github.com/influxdata/influxdb-client-go/v2/api"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
type v2Reporter struct {
diff --git go-ethereum/metrics/internal/sampledata.go op-geth/metrics/internal/sampledata.go
index de9b207b6d4ad903069717fe8f5bd3d6270006a9..65c2923f73b276cfd52a31bfbfe2e35fd12fe242 100644
--- go-ethereum/metrics/internal/sampledata.go
+++ op-geth/metrics/internal/sampledata.go
@@ -22,7 +22,7 @@ "encoding/gob"
metrics2 "runtime/metrics"
"time"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/metrics"
)
// ExampleMetrics returns an ordered registry populated with a sample of metrics.
diff --git go-ethereum/metrics/librato/librato.go op-geth/metrics/librato/librato.go
index a86f758637869f15e7372ba1f684119c07586763..7bdea915a6a04ab947bae75ce197aef2c6b97092 100644
--- go-ethereum/metrics/librato/librato.go
+++ op-geth/metrics/librato/librato.go
@@ -7,7 +7,7 @@ "math"
"regexp"
"time"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/metrics"
)
// a regexp for extracting the unit from time.Duration.String
diff --git go-ethereum/metrics/metrics.go op-geth/metrics/metrics.go
index 9ca8f115c0f789cfa2b7ab52069b7e0e4cb08d3a..66ba5653eecd8ed6032c541e7c19a9cf58d38e15 100644
--- go-ethereum/metrics/metrics.go
+++ op-geth/metrics/metrics.go
@@ -14,7 +14,7 @@ "strings"
"syscall"
"time"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
// Enabled is checked by the constructor functions for all of the
diff --git go-ethereum/metrics/prometheus/collector.go op-geth/metrics/prometheus/collector.go
index 25b258d56ab125d22f9a884720fd58afc1ee0a83..491ef0d37a8e3d9c11939fe37d6fa4539d981d23 100644
--- go-ethereum/metrics/prometheus/collector.go
+++ op-geth/metrics/prometheus/collector.go
@@ -23,7 +23,7 @@ "sort"
"strconv"
"strings"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/metrics"
)
var (
diff --git go-ethereum/metrics/prometheus/prometheus.go op-geth/metrics/prometheus/prometheus.go
index dbdeae6c7f7d3b1450e28c816432f9eca07e3953..599bbb89347171988f3abef5f27391eeccbfc8a5 100644
--- go-ethereum/metrics/prometheus/prometheus.go
+++ op-geth/metrics/prometheus/prometheus.go
@@ -22,8 +22,8 @@ "fmt"
"net/http"
"sort"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
// Handler returns an HTTP handler which dump metrics in Prometheus format.
diff --git go-ethereum/miner/stress/clique/main.go op-geth/miner/stress/clique/main.go
index 60593938458b05d5393983bb220f291c864354e2..bd84078be62be7c267d29a5a8c39189caf8b81c3 100644
--- go-ethereum/miner/stress/clique/main.go
+++ op-geth/miner/stress/clique/main.go
@@ -26,22 +26,22 @@ "os"
"os/signal"
"time"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/fdlimit"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/txpool/legacypool"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/eth/ethconfig"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/miner"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/fdlimit"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/txpool/legacypool"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/eth"
+ "github.com/tenderly/op-geth/eth/downloader"
+ "github.com/tenderly/op-geth/eth/ethconfig"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/miner"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/params"
)
func main() {
diff --git go-ethereum/node/api.go op-geth/node/api.go
index f81f394beb24a72068a968c248b9894da31717b1..d3e7f660379a9b0696923ca1f6a635b517738e71 100644
--- go-ethereum/node/api.go
+++ op-geth/node/api.go
@@ -21,13 +21,13 @@ "context"
"fmt"
"strings"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/debug"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/debug"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/rpc"
)
// apis returns the collection of built-in RPC APIs.
diff --git go-ethereum/node/config.go op-geth/node/config.go
index 949db887e4e4bf4d841c0db62d31844e2671c58d..a547f6e30e4c3482c93888f6fe19dca37f8f1790 100644
--- go-ethereum/node/config.go
+++ op-geth/node/config.go
@@ -25,11 +25,11 @@ "path/filepath"
"runtime"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/rpc"
)
const (
diff --git go-ethereum/node/defaults.go op-geth/node/defaults.go
index 307d9e186a251b7963b5fbb4266249fbfbcc6fa4..725c9c83718ee5d4677072473a1c80116d64048c 100644
--- go-ethereum/node/defaults.go
+++ op-geth/node/defaults.go
@@ -22,9 +22,9 @@ "os/user"
"path/filepath"
"runtime"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/nat"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/nat"
+ "github.com/tenderly/op-geth/rpc"
)
const (
diff --git go-ethereum/node/endpoints.go op-geth/node/endpoints.go
index 14c12fd1f175b6c0ebf4c14b0bfd999a7eb970a8..7b3b40ffd3469a639ae479912f20dc4c9610ce4c 100644
--- go-ethereum/node/endpoints.go
+++ op-geth/node/endpoints.go
@@ -21,8 +21,8 @@ "net"
"net/http"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rpc"
)
// StartHTTPEndpoint starts the HTTP RPC endpoint.
diff --git go-ethereum/node/jwt_auth.go op-geth/node/jwt_auth.go
index d4f8193ca7f22e7748bf1140d9fa84401bb4b920..6fea773f22ffd33ff38e5def8168ba32735d1d8e 100644
--- go-ethereum/node/jwt_auth.go
+++ op-geth/node/jwt_auth.go
@@ -21,8 +21,8 @@ "fmt"
"net/http"
"time"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/golang-jwt/jwt/v4"
+ "github.com/tenderly/op-geth/rpc"
)
// NewJWTAuth creates an rpc client authentication provider that uses JWT. The
diff --git go-ethereum/node/node.go op-geth/node/node.go
index dfa83d58c7260fee12076b11f5d045cd699b2333..36f2383645f33846e2240720f6f6959a5c997d8c 100644
--- go-ethereum/node/node.go
+++ op-geth/node/node.go
@@ -28,16 +28,16 @@ "reflect"
"strings"
"sync"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/gofrs/flock"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/rpc"
)
// Node is a container on which services can be registered.
@@ -680,7 +680,7 @@
// HTTPEndpoint returns the URL of the HTTP server. Note that this URL does not
// contain the JSON-RPC path prefix set by HTTPPathPrefix.
func (n *Node) HTTPEndpoint() string {
- return "http://" + n.http.listenAddr()
+ return "http://" + n.http.listenAddr() //nolint:all
}
// WSEndpoint returns the current JSON-RPC over WebSocket endpoint.
diff --git go-ethereum/node/rpcstack.go op-geth/node/rpcstack.go
index d80d5271a7fafc36636eec6a29b369e0dbb9e3c5..bc18397d472783ed86e084d70ae7fc5ea96d209f 100644
--- go-ethereum/node/rpcstack.go
+++ op-geth/node/rpcstack.go
@@ -30,9 +30,9 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/rs/cors"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rpc"
)
// httpConfig is the JSON-RPC/HTTP configuration.
diff --git go-ethereum/oss-fuzz.sh op-geth/oss-fuzz.sh
index 8978de70dde9a5f864777ba2a41dd5ed764ef7dc..8acabec762d71c8c2cd941c9d3a8b4d6b22c7439 100644
--- go-ethereum/oss-fuzz.sh
+++ op-geth/oss-fuzz.sh
@@ -16,7 +16,7 @@ #
################################################################################
# This sets the -coverpgk for the coverage report when the corpus is executed through go test
-coverpkg="github.com/ethereum/go-ethereum/..."
+coverpkg="github.com/tenderly/op-geth/..."
function coverbuild {
path=$1
@@ -81,134 +81,134 @@ cd -
}
go install github.com/holiman/gofuzz-shim@latest
-repo=$GOPATH/src/github.com/ethereum/go-ethereum
-compile_fuzzer github.com/ethereum/go-ethereum/accounts/abi \
+repo=$GOPATH/src/github.com/tenderly/op-geth
+compile_fuzzer github.com/tenderly/op-geth/accounts/abi \
FuzzABI fuzzAbi \
$repo/accounts/abi/abifuzzer_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/common/bitutil \
+compile_fuzzer github.com/tenderly/op-geth/common/bitutil \
FuzzEncoder fuzzBitutilEncoder \
$repo/common/bitutil/compress_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/common/bitutil \
+compile_fuzzer github.com/tenderly/op-geth/common/bitutil \
FuzzDecoder fuzzBitutilDecoder \
$repo/common/bitutil/compress_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/core/vm/runtime \
+compile_fuzzer github.com/tenderly/op-geth/core/vm/runtime \
FuzzVmRuntime fuzzVmRuntime\
$repo/core/vm/runtime/runtime_fuzz_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/core/vm \
+compile_fuzzer github.com/tenderly/op-geth/core/vm \
FuzzPrecompiledContracts fuzzPrecompiledContracts\
$repo/core/vm/contracts_fuzz_test.go,$repo/core/vm/contracts_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/core/types \
+compile_fuzzer github.com/tenderly/op-geth/core/types \
FuzzRLP fuzzRlp \
$repo/core/types/rlp_fuzzer_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/crypto/blake2b \
+compile_fuzzer github.com/tenderly/op-geth/crypto/blake2b \
Fuzz fuzzBlake2b \
$repo/crypto/blake2b/blake2b_f_fuzz_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/accounts/keystore \
+compile_fuzzer github.com/tenderly/op-geth/accounts/keystore \
FuzzPassword fuzzKeystore \
$repo/accounts/keystore/keystore_fuzzing_test.go
pkg=$repo/trie/
-compile_fuzzer github.com/ethereum/go-ethereum/trie \
+compile_fuzzer github.com/tenderly/op-geth/trie \
FuzzTrie fuzzTrie \
$pkg/trie_test.go,$pkg/database_test.go,$pkg/tracer_test.go,$pkg/proof_test.go,$pkg/iterator_test.go,$pkg/sync_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/trie \
+compile_fuzzer github.com/tenderly/op-geth/trie \
FuzzStackTrie fuzzStackTrie \
$pkg/stacktrie_fuzzer_test.go,$pkg/iterator_test.go,$pkg/trie_test.go,$pkg/database_test.go,$pkg/tracer_test.go,$pkg/proof_test.go,$pkg/sync_test.go
#compile_fuzzer tests/fuzzers/snap FuzzARange fuzz_account_range
-compile_fuzzer github.com/ethereum/go-ethereum/eth/protocols/snap \
+compile_fuzzer github.com/tenderly/op-geth/eth/protocols/snap \
FuzzARange fuzz_account_range \
$repo/eth/protocols/snap/handler_fuzzing_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/eth/protocols/snap \
+compile_fuzzer github.com/tenderly/op-geth/eth/protocols/snap \
FuzzSRange fuzz_storage_range \
$repo/eth/protocols/snap/handler_fuzzing_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/eth/protocols/snap \
+compile_fuzzer github.com/tenderly/op-geth/eth/protocols/snap \
FuzzByteCodes fuzz_byte_codes \
$repo/eth/protocols/snap/handler_fuzzing_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/eth/protocols/snap \
+compile_fuzzer github.com/tenderly/op-geth/eth/protocols/snap \
FuzzTrieNodes fuzz_trie_nodes\
$repo/eth/protocols/snap/handler_fuzzing_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bn256 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bn256 \
FuzzAdd fuzzBn256Add\
$repo/tests/fuzzers/bn256/bn256_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bn256 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bn256 \
FuzzMul fuzzBn256Mul \
$repo/tests/fuzzers/bn256/bn256_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bn256 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bn256 \
FuzzPair fuzzBn256Pair \
$repo/tests/fuzzers/bn256/bn256_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/txfetcher \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/txfetcher \
Fuzz fuzzTxfetcher \
$repo/tests/fuzzers/txfetcher/txfetcher_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzG1Add fuzz_g1_add\
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzG1Mul fuzz_g1_mul\
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzG1MultiExp fuzz_g1_multiexp \
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzG2Add fuzz_g2_add \
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzG2Mul fuzz_g2_mul\
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzG2MultiExp fuzz_g2_multiexp \
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzPairing fuzz_pairing \
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzMapG1 fuzz_map_g1\
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzMapG2 fuzz_map_g2 \
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzCrossG1Add fuzz_cross_g1_add \
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzCrossG1MultiExp fuzz_cross_g1_multiexp \
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzCrossG2Add fuzz_cross_g2_add \
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/bls12381 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/bls12381 \
FuzzCrossPairing fuzz_cross_pairing\
$repo/tests/fuzzers/bls12381/bls12381_test.go
-compile_fuzzer github.com/ethereum/go-ethereum/tests/fuzzers/secp256k1 \
+compile_fuzzer github.com/tenderly/op-geth/tests/fuzzers/secp256k1 \
Fuzz fuzzSecp256k1\
$repo/tests/fuzzers/secp256k1/secp_test.go
diff --git go-ethereum/p2p/dial.go op-geth/p2p/dial.go
index 5e4ab1d50dcc44fc103d686eac30677029eb1b66..bac2f217e452a4792628835de1876ca09879fa33 100644
--- go-ethereum/p2p/dial.go
+++ op-geth/p2p/dial.go
@@ -27,10 +27,10 @@ "net"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/netutil"
)
const (
diff --git go-ethereum/p2p/discover/common.go op-geth/p2p/discover/common.go
index c9f0477defebc44303a279155b0005284ae66def..3678fa2ac492434d9f16de07e966354f0b9d1349 100644
--- go-ethereum/p2p/discover/common.go
+++ op-geth/p2p/discover/common.go
@@ -21,11 +21,11 @@ "crypto/ecdsa"
"net"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/p2p/netutil"
)
// UDPConn is a network connection on which discovery can operate.
diff --git go-ethereum/p2p/discover/lookup.go op-geth/p2p/discover/lookup.go
index b8d97b44e1cc50a841e23b2d4147833ff4490a44..7eb287880a3e3ba4a67af9cb8bd7da78b387066a 100644
--- go-ethereum/p2p/discover/lookup.go
+++ op-geth/p2p/discover/lookup.go
@@ -21,7 +21,7 @@ "context"
"errors"
"time"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// lookup performs a network search for nodes close to the given target. It approaches the
diff --git go-ethereum/p2p/discover/metrics.go op-geth/p2p/discover/metrics.go
index 56aae24285dfebbd32b32514713841ef765102c6..496e304b2bf230ea0bed56b4857ed696605c5272 100644
--- go-ethereum/p2p/discover/metrics.go
+++ op-geth/p2p/discover/metrics.go
@@ -20,7 +20,7 @@ import (
"fmt"
"net"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/metrics"
)
const (
diff --git go-ethereum/p2p/discover/node.go op-geth/p2p/discover/node.go
index 9ffe101ccff85a9e6d104c046788c0672690ac04..7a0724d3244d6a4a7d6f220ea8a2192fafbdc01f 100644
--- go-ethereum/p2p/discover/node.go
+++ op-geth/p2p/discover/node.go
@@ -24,9 +24,9 @@ "math/big"
"net"
"time"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// node represents a host on the network.
diff --git go-ethereum/p2p/discover/ntp.go op-geth/p2p/discover/ntp.go
index 3f9157808f12475782e20e46c5c91ed303641628..1fb0580f86c5e08992b454f77fa5705afdf5ebdf 100644
--- go-ethereum/p2p/discover/ntp.go
+++ op-geth/p2p/discover/ntp.go
@@ -24,7 +24,7 @@ "fmt"
"net"
"time"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/p2p/discover/table.go op-geth/p2p/discover/table.go
index 2b7a28708b8d1423d2942472ba7fd881a0a6dce0..3f0ba34181aa86140e7fa1ec589722098c1f9817 100644
--- go-ethereum/p2p/discover/table.go
+++ op-geth/p2p/discover/table.go
@@ -33,11 +33,11 @@ "sort"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/netutil"
)
const (
diff --git go-ethereum/p2p/discover/v4_udp.go op-geth/p2p/discover/v4_udp.go
index 988f16b01df2c11af84d52f3c77784c37c65131a..9b00fabf79654b86a75e0bea2b2aa521ad81839a 100644
--- go-ethereum/p2p/discover/v4_udp.go
+++ op-geth/p2p/discover/v4_udp.go
@@ -29,11 +29,11 @@ "net"
"sync"
"time"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/discover/v4wire"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/discover/v4wire"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/netutil"
)
// Errors
diff --git go-ethereum/p2p/discover/v4wire/v4wire.go op-geth/p2p/discover/v4wire/v4wire.go
index 9c59359fb2c2e005503c3462f2305d58d260f24c..3a995a8903b9a2f1e2f70f52a8037375b3d166b6 100644
--- go-ethereum/p2p/discover/v4wire/v4wire.go
+++ op-geth/p2p/discover/v4wire/v4wire.go
@@ -27,11 +27,11 @@ "math/big"
"net"
"time"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
)
// RPC packet types
diff --git go-ethereum/p2p/discover/v5_talk.go op-geth/p2p/discover/v5_talk.go
index c1f67879402c80f30b2de50f7b688315e5b29371..e018ecc1282f2962ffa937c31e56cba958272b82 100644
--- go-ethereum/p2p/discover/v5_talk.go
+++ op-geth/p2p/discover/v5_talk.go
@@ -21,9 +21,9 @@ "net"
"sync"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/discover/v5wire"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/discover/v5wire"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// This is a limit for the number of concurrent talk requests.
diff --git go-ethereum/p2p/discover/v5_udp.go op-geth/p2p/discover/v5_udp.go
index 8b3e33d37cf73b0b89aa1aeefbac5f34b02d7262..3a7e00595085cb89c0bef8c67cd66f7a79015799 100644
--- go-ethereum/p2p/discover/v5_udp.go
+++ op-geth/p2p/discover/v5_udp.go
@@ -28,12 +28,12 @@ "net"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/discover/v5wire"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/discover/v5wire"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/p2p/netutil"
)
const (
diff --git go-ethereum/p2p/discover/v5wire/crypto.go op-geth/p2p/discover/v5wire/crypto.go
index fc0a0edef59460fd495f084622ea6eec4da19fa6..95e361c95f8b947333e7c662cf907a09ca414fdd 100644
--- go-ethereum/p2p/discover/v5wire/crypto.go
+++ op-geth/p2p/discover/v5wire/crypto.go
@@ -25,9 +25,9 @@ "errors"
"fmt"
"hash"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enode"
"golang.org/x/crypto/hkdf"
)
diff --git go-ethereum/p2p/discover/v5wire/encoding.go op-geth/p2p/discover/v5wire/encoding.go
index 5108910620e0b38b4e8830f7d4b728a3becfc723..7d0b9f07f50796275a660df8445a8ce1fb204a22 100644
--- go-ethereum/p2p/discover/v5wire/encoding.go
+++ op-geth/p2p/discover/v5wire/encoding.go
@@ -28,10 +28,10 @@ "errors"
"fmt"
"hash"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
)
// TODO concurrent WHOAREYOU tie-breaker
diff --git go-ethereum/p2p/discover/v5wire/msg.go op-geth/p2p/discover/v5wire/msg.go
index 401db2f6c587f94e8b39342c341e9ed913c886c1..66f916e4eae337186386cd1739074f3ac421e2be 100644
--- go-ethereum/p2p/discover/v5wire/msg.go
+++ op-geth/p2p/discover/v5wire/msg.go
@@ -20,11 +20,11 @@ import (
"fmt"
"net"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
)
// Packet is implemented by all message types.
diff --git go-ethereum/p2p/discover/v5wire/session.go op-geth/p2p/discover/v5wire/session.go
index 862c21fcee9fcd33e561388ebc8cf371f2d9d082..a8a53f3ad4bc1404ee0af5a2b26ab66c218d71a0 100644
--- go-ethereum/p2p/discover/v5wire/session.go
+++ op-geth/p2p/discover/v5wire/session.go
@@ -22,10 +22,10 @@ crand "crypto/rand"
"encoding/binary"
"time"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enode"
)
const handshakeTimeout = time.Second
diff --git go-ethereum/p2p/dnsdisc/client.go op-geth/p2p/dnsdisc/client.go
index 8f1c221b80387e2964b30633cd26df468a38491f..cfa5c5d755628cfe14772dfdd0ff6cac4953e5dc 100644
--- go-ethereum/p2p/dnsdisc/client.go
+++ op-geth/p2p/dnsdisc/client.go
@@ -27,12 +27,12 @@ "strings"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
"golang.org/x/sync/singleflight"
"golang.org/x/time/rate"
)
diff --git go-ethereum/p2p/dnsdisc/sync.go op-geth/p2p/dnsdisc/sync.go
index 073547c90d030239623ee40d0ad39a719d091739..1f4fbaf5963f7c2a7bbee5cc9d5ed7b1e7e7c919 100644
--- go-ethereum/p2p/dnsdisc/sync.go
+++ op-geth/p2p/dnsdisc/sync.go
@@ -21,8 +21,8 @@ "context"
"math/rand"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// This is the number of consecutive leaf requests that may fail before
diff --git go-ethereum/p2p/dnsdisc/tree.go op-geth/p2p/dnsdisc/tree.go
index 7d9703a3455858be34231b488b559edb49019d2a..989db9e759f7bf91002ad03dd42cdd3e2021f9b7 100644
--- go-ethereum/p2p/dnsdisc/tree.go
+++ op-geth/p2p/dnsdisc/tree.go
@@ -25,10 +25,10 @@ "fmt"
"io"
"strings"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/crypto/sha3"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/p2p/enode/idscheme.go op-geth/p2p/enode/idscheme.go
index fd5d868b761db0ce26baff223b57c27cc3fd96e5..4a439cb03ff17a018eb027ff63ff82bb16e5a723 100644
--- go-ethereum/p2p/enode/idscheme.go
+++ op-geth/p2p/enode/idscheme.go
@@ -21,10 +21,10 @@ "crypto/ecdsa"
"fmt"
"io"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/p2p/enode/localnode.go op-geth/p2p/enode/localnode.go
index a18204e752ce8d86bd9b4bb8d135218d6b47e19c..e05268b29b947f249e21ffaefdafed31a2c50a1c 100644
--- go-ethereum/p2p/enode/localnode.go
+++ op-geth/p2p/enode/localnode.go
@@ -26,9 +26,9 @@ "sync"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/p2p/netutil"
)
const (
diff --git go-ethereum/p2p/enode/node.go op-geth/p2p/enode/node.go
index d7a1a9a1561c968bf7275bc6f6670d0eeebc720b..14543648f773c250c8c7492eb802d0be4d15aa51 100644
--- go-ethereum/p2p/enode/node.go
+++ op-geth/p2p/enode/node.go
@@ -26,8 +26,8 @@ "math/bits"
"net"
"strings"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
)
var errMissingPrefix = errors.New("missing 'enr:' prefix for base64-encoded record")
diff --git go-ethereum/p2p/enode/nodedb.go op-geth/p2p/enode/nodedb.go
index 7e7fb69b293aefd159478fe1e001afba9e445047..370fd02b18d35dd673aed9fa40a0b0b8d3bd9d9e 100644
--- go-ethereum/p2p/enode/nodedb.go
+++ op-geth/p2p/enode/nodedb.go
@@ -26,13 +26,13 @@ "os"
"sync"
"time"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/syndtr/goleveldb/leveldb"
"github.com/syndtr/goleveldb/leveldb/errors"
"github.com/syndtr/goleveldb/leveldb/iterator"
"github.com/syndtr/goleveldb/leveldb/opt"
"github.com/syndtr/goleveldb/leveldb/storage"
"github.com/syndtr/goleveldb/leveldb/util"
+ "github.com/tenderly/op-geth/rlp"
)
// Keys in the node database.
diff --git go-ethereum/p2p/enode/urlv4.go op-geth/p2p/enode/urlv4.go
index 0272eee98725f99266c6bfb20113057485815d35..acf0b99f49e4fe0e4cef7edb69f73037f8d4ebae 100644
--- go-ethereum/p2p/enode/urlv4.go
+++ op-geth/p2p/enode/urlv4.go
@@ -26,9 +26,9 @@ "net/url"
"regexp"
"strconv"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/p2p/enr"
)
var (
diff --git go-ethereum/p2p/enr/enr.go op-geth/p2p/enr/enr.go
index 2b093b2f1ab106851731358171c34e82129e6584..6f748367bfea13ac6bd565350b3bce12cb44e5f0 100644
--- go-ethereum/p2p/enr/enr.go
+++ op-geth/p2p/enr/enr.go
@@ -40,7 +40,7 @@ "fmt"
"io"
"sort"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/rlp"
)
const SizeLimit = 300 // maximum encoded size of a node record in bytes
diff --git go-ethereum/p2p/enr/entries.go op-geth/p2p/enr/entries.go
index 9945a436c9f8f7cfbf891141664035bc11deebd3..88becf989606e780c55cf98260488bf142cff69d 100644
--- go-ethereum/p2p/enr/entries.go
+++ op-geth/p2p/enr/entries.go
@@ -22,7 +22,7 @@ "fmt"
"io"
"net"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/rlp"
)
// Entry is implemented by known node record entry types.
diff --git go-ethereum/p2p/message.go op-geth/p2p/message.go
index 3ab56ee35018d1146566bbf46825190e443ef6ed..72c9a26ecb2a2c0a6a76ad99bd1a5991114eb74c 100644
--- go-ethereum/p2p/message.go
+++ op-geth/p2p/message.go
@@ -24,9 +24,9 @@ "io"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/rlp"
)
// Msg defines the structure of a p2p message.
diff --git go-ethereum/p2p/metrics.go op-geth/p2p/metrics.go
index a6e36b91a8d77379b4d67de691136758d2ccb2a0..381e24ed2fc8d17ea910f6ea2de85203fdb9cfba 100644
--- go-ethereum/p2p/metrics.go
+++ op-geth/p2p/metrics.go
@@ -22,7 +22,7 @@ import (
"errors"
"net"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/metrics"
)
const (
diff --git go-ethereum/p2p/msgrate/msgrate.go op-geth/p2p/msgrate/msgrate.go
index de1a3177db0fd9e82e85bea8b87e573e6e321307..940bb2570ee1eeec987ccc2dde8501fd4bb3000b 100644
--- go-ethereum/p2p/msgrate/msgrate.go
+++ op-geth/p2p/msgrate/msgrate.go
@@ -25,7 +25,7 @@ "sort"
"sync"
"time"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
// measurementImpact is the impact a single measurement has on a peer's final
diff --git go-ethereum/p2p/nat/nat.go op-geth/p2p/nat/nat.go
index 2aa1f855852a1685e26b961257c9c738ee01c738..449cf3710e2474bec2699ad762064e001e42e6d4 100644
--- go-ethereum/p2p/nat/nat.go
+++ op-geth/p2p/nat/nat.go
@@ -25,8 +25,8 @@ "strings"
"sync"
"time"
- "github.com/ethereum/go-ethereum/log"
natpmp "github.com/jackpal/go-nat-pmp"
+ "github.com/tenderly/op-geth/log"
)
// Interface An implementation of nat.Interface can map local ports to ports
diff --git go-ethereum/p2p/netutil/iptrack.go op-geth/p2p/netutil/iptrack.go
index a070499e19dc1ff6b4537b41bd63d70edec6fb9a..0a1e5e911bc181de6057aaed6458888ddd227ad8 100644
--- go-ethereum/p2p/netutil/iptrack.go
+++ op-geth/p2p/netutil/iptrack.go
@@ -19,7 +19,7 @@
import (
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
+ "github.com/tenderly/op-geth/common/mclock"
)
// IPTracker predicts the external endpoint, i.e. IP address and port, of the local host
diff --git go-ethereum/p2p/nodestate/nodestate.go op-geth/p2p/nodestate/nodestate.go
index 1e1757559c02af5748980178db881eee2467061d..8b332d29c7a37999809c74e2398d26249f9434d6 100644
--- go-ethereum/p2p/nodestate/nodestate.go
+++ op-geth/p2p/nodestate/nodestate.go
@@ -23,13 +23,13 @@ "sync"
"time"
"unsafe"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
)
var (
diff --git go-ethereum/p2p/peer.go op-geth/p2p/peer.go
index 65a7903f58635d9ce7f514b6165375a39716cae9..c57ca1de8ee0a1717db6f6e338fe4722b279f165 100644
--- go-ethereum/p2p/peer.go
+++ op-geth/p2p/peer.go
@@ -24,13 +24,13 @@ "net"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/p2p/protocol.go op-geth/p2p/protocol.go
index 9bb6785a2250064fb473964421349c628061f142..56d8bc1ab83beb476ee35ba2e8686d905a54edd6 100644
--- go-ethereum/p2p/protocol.go
+++ op-geth/p2p/protocol.go
@@ -20,8 +20,8 @@ import (
"fmt"
"strings"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
)
// Protocol represents a P2P subprotocol implementation.
diff --git go-ethereum/p2p/rlpx/rlpx.go op-geth/p2p/rlpx/rlpx.go
index 8bd6f64b9bd301ede8fc6111ba574b2297e03e9a..1ef25e41e111ac6e9e08f312e7c79ffa69eed871 100644
--- go-ethereum/p2p/rlpx/rlpx.go
+++ op-geth/p2p/rlpx/rlpx.go
@@ -34,10 +34,10 @@ mrand "math/rand"
"net"
"time"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/crypto/ecies"
- "github.com/ethereum/go-ethereum/rlp"
"github.com/golang/snappy"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/crypto/ecies"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/p2p/server_nat.go op-geth/p2p/server_nat.go
index 299d27549005f954e891eb00800d582ddcc56964..c2f7909290d280b4300918e60bf0cd63512e9308 100644
--- go-ethereum/p2p/server_nat.go
+++ op-geth/p2p/server_nat.go
@@ -20,10 +20,10 @@ import (
"net"
"time"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/p2p/nat"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/p2p/nat"
)
const (
diff --git go-ethereum/p2p/simulations/adapters/exec.go op-geth/p2p/simulations/adapters/exec.go
index 63cc4936c1bdadd9a32aea940b86fc9ad5c2d67c..20424079ac8d44c3d544208ae1548aefad9fe7b6 100644
--- go-ethereum/p2p/simulations/adapters/exec.go
+++ op-geth/p2p/simulations/adapters/exec.go
@@ -34,13 +34,13 @@ "sync"
"syscall"
"time"
- "github.com/ethereum/go-ethereum/internal/reexec"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/gorilla/websocket"
+ "github.com/tenderly/op-geth/internal/reexec"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/rpc"
"golang.org/x/exp/slog"
)
diff --git go-ethereum/p2p/simulations/adapters/inproc.go op-geth/p2p/simulations/adapters/inproc.go
index 349e496b2f68ef11a6d1d1c3a8a7c22ef932a75c..8b45875ae52015c5e732c8ff6be60f2536a237c8 100644
--- go-ethereum/p2p/simulations/adapters/inproc.go
+++ op-geth/p2p/simulations/adapters/inproc.go
@@ -24,14 +24,14 @@ "math"
"net"
"sync"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/simulations/pipes"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/gorilla/websocket"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/simulations/pipes"
+ "github.com/tenderly/op-geth/rpc"
)
// SimAdapter is a NodeAdapter which creates in-memory simulation nodes and
diff --git go-ethereum/p2p/simulations/adapters/types.go op-geth/p2p/simulations/adapters/types.go
index fb8463d221ebebe3661410815eea3cbf4f45b3fd..bf73e72d7cbab23024a99f14fa1fa66959e46436 100644
--- go-ethereum/p2p/simulations/adapters/types.go
+++ op-geth/p2p/simulations/adapters/types.go
@@ -25,15 +25,15 @@ "net"
"os"
"strconv"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/internal/reexec"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/gorilla/websocket"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/internal/reexec"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rpc"
"golang.org/x/exp/slog"
)
diff --git go-ethereum/p2p/simulations/connect.go op-geth/p2p/simulations/connect.go
index ede96b34c133810819db11c5e706e73b13104297..5238a99e6e90aed58742f5dfcdb26e4a4747e5c9 100644
--- go-ethereum/p2p/simulations/connect.go
+++ op-geth/p2p/simulations/connect.go
@@ -20,7 +20,7 @@ import (
"errors"
"strings"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enode"
)
var (
diff --git go-ethereum/p2p/simulations/examples/ping-pong.go op-geth/p2p/simulations/examples/ping-pong.go
index 70b35ad77742134ee3cbb8b5f6a20deea2f852f3..d87929afcd1e66f5346ec32d47114e458aca84ae 100644
--- go-ethereum/p2p/simulations/examples/ping-pong.go
+++ op-geth/p2p/simulations/examples/ping-pong.go
@@ -25,12 +25,12 @@ "os"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/simulations"
- "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/node"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/simulations"
+ "github.com/tenderly/op-geth/p2p/simulations/adapters"
)
var adapterType = flag.String("adapter", "sim", `node adapter to use (one of "sim", "exec" or "docker")`)
diff --git go-ethereum/p2p/simulations/http.go op-geth/p2p/simulations/http.go
index 34521b47789863597a6b01a4e2bf41ccc58eb720..572233dab9dcbce8b6abd76985167387b3519b84 100644
--- go-ethereum/p2p/simulations/http.go
+++ op-geth/p2p/simulations/http.go
@@ -30,13 +30,13 @@ "strconv"
"strings"
"sync"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
- "github.com/ethereum/go-ethereum/rpc"
"github.com/gorilla/websocket"
"github.com/julienschmidt/httprouter"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/simulations/adapters"
+ "github.com/tenderly/op-geth/rpc"
)
// DefaultClient is the default simulation API client which expects the API
diff --git go-ethereum/p2p/simulations/mocker.go op-geth/p2p/simulations/mocker.go
index 0dc04e65f921a51d81b987d5e067529ae6eb1a6c..04310b1eb28114e45aff5195eaf83ad9fe7137d2 100644
--- go-ethereum/p2p/simulations/mocker.go
+++ op-geth/p2p/simulations/mocker.go
@@ -24,9 +24,9 @@ "math/rand"
"sync"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/simulations/adapters"
)
// a map of mocker names to its function
diff --git go-ethereum/p2p/simulations/network.go op-geth/p2p/simulations/network.go
index 4735e5cfa6cf89b1277360887eabf3727143ae95..dbab22e4a409114866f30438701bdef50a4422de 100644
--- go-ethereum/p2p/simulations/network.go
+++ op-geth/p2p/simulations/network.go
@@ -26,11 +26,11 @@ "math/rand"
"sync"
"time"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+ "github.com/tenderly/op-geth/event"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/simulations/adapters"
)
var DialBanTimeout = 200 * time.Millisecond
diff --git go-ethereum/p2p/simulations/simulation.go op-geth/p2p/simulations/simulation.go
index ae62c42b9c2dd1b1cc4cb154c8c8c1389e3ad890..468bd5f36f9c537abff85bedbb990016c7a8b921 100644
--- go-ethereum/p2p/simulations/simulation.go
+++ op-geth/p2p/simulations/simulation.go
@@ -20,7 +20,7 @@ import (
"context"
"time"
- "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enode"
)
// Simulation provides a framework for running actions in a simulated network
diff --git go-ethereum/p2p/simulations/test.go op-geth/p2p/simulations/test.go
index 0edb07b127f8e059eb65e4d638af57fd3294fc9d..75f22dee0c63994a8e3afa64a228e1138ea9e3c1 100644
--- go-ethereum/p2p/simulations/test.go
+++ op-geth/p2p/simulations/test.go
@@ -19,10 +19,10 @@
import (
"testing"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/enode"
- "github.com/ethereum/go-ethereum/p2p/enr"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/p2p"
+ "github.com/tenderly/op-geth/p2p/enode"
+ "github.com/tenderly/op-geth/p2p/enr"
+ "github.com/tenderly/op-geth/rpc"
)
// NoopService is the service that does not do anything
diff --git go-ethereum/p2p/tracker/tracker.go op-geth/p2p/tracker/tracker.go
index 6a733b9ba51e31fb9e4dd10f28678ac06d85714e..d29a64cebd038be1659653b84fc7f2eecbc5620f 100644
--- go-ethereum/p2p/tracker/tracker.go
+++ op-geth/p2p/tracker/tracker.go
@@ -22,8 +22,8 @@ "fmt"
"sync"
"time"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
const (
diff --git go-ethereum/p2p/transport.go op-geth/p2p/transport.go
index 5fc7686feb06a77b3a87ceea331be6212684e490..e7ca0eac0d41b425b02020a386ea76e1a82f25eb 100644
--- go-ethereum/p2p/transport.go
+++ op-geth/p2p/transport.go
@@ -26,11 +26,11 @@ "net"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/bitutil"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/p2p/rlpx"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/bitutil"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/p2p/rlpx"
+ "github.com/tenderly/op-geth/rlp"
)
const (
diff --git go-ethereum/p2p/util.go op-geth/p2p/util.go
index 2c8f322a66acc9436c30372ac82f7a6807c2b8e5..2c2ba226ad010d3bdc0837b5c67316843798bfe9 100644
--- go-ethereum/p2p/util.go
+++ op-geth/p2p/util.go
@@ -19,7 +19,7 @@
import (
"container/heap"
- "github.com/ethereum/go-ethereum/common/mclock"
+ "github.com/tenderly/op-geth/common/mclock"
)
// expHeap tracks strings and their expiry time.
diff --git go-ethereum/params/dao.go op-geth/params/dao.go
index da3c8dfc992b38e9bb18368ef5b293f293d2aa4b..dfd8ab62e391fdc53862d7f17d6958cd4a05bf5f 100644
--- go-ethereum/params/dao.go
+++ op-geth/params/dao.go
@@ -19,7 +19,7 @@
import (
"math/big"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// DAOForkBlockExtra is the block header extra-data field to set for the DAO fork
diff --git go-ethereum/rlp/decode.go op-geth/rlp/decode.go
index 9b17d2d810846b4c5473644bfda167bcca6593db..fa5fb94dcc761d4a364aa3f53b2df1b5e571335b 100644
--- go-ethereum/rlp/decode.go
+++ op-geth/rlp/decode.go
@@ -28,8 +28,8 @@ "reflect"
"strings"
"sync"
- "github.com/ethereum/go-ethereum/rlp/internal/rlpstruct"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/rlp/internal/rlpstruct"
)
//lint:ignore ST1012 EOL is not an error.
diff --git go-ethereum/rlp/encode.go op-geth/rlp/encode.go
index ffb42b29977c6ee771f42336e146a20d48996fef..35d52b24fe92e303d69a3d6c0b6a02ee420e5177 100644
--- go-ethereum/rlp/encode.go
+++ op-geth/rlp/encode.go
@@ -23,8 +23,8 @@ "io"
"math/big"
"reflect"
- "github.com/ethereum/go-ethereum/rlp/internal/rlpstruct"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/rlp/internal/rlpstruct"
)
var (
diff --git go-ethereum/rlp/rlpgen/gen.go op-geth/rlp/rlpgen/gen.go
index 0c6586482698329fc09075d9dba9a97d663a2bb6..6ae821aac6c6a18be4d2dddd750a9d8ad3250eeb 100644
--- go-ethereum/rlp/rlpgen/gen.go
+++ op-geth/rlp/rlpgen/gen.go
@@ -23,7 +23,7 @@ "go/format"
"go/types"
"sort"
- "github.com/ethereum/go-ethereum/rlp/internal/rlpstruct"
+ "github.com/tenderly/op-geth/rlp/internal/rlpstruct"
)
// buildContext keeps the data needed for make*Op.
diff --git go-ethereum/rlp/rlpgen/main.go op-geth/rlp/rlpgen/main.go
index b3a74b9df13f817e33e6e9940e4e731fe1a0e4b6..bc31d9559eac080ba184389c7aa91f7de6fbcfe5 100644
--- go-ethereum/rlp/rlpgen/main.go
+++ op-geth/rlp/rlpgen/main.go
@@ -27,7 +27,7 @@
"golang.org/x/tools/go/packages"
)
-const pathOfPackageRLP = "github.com/ethereum/go-ethereum/rlp"
+const pathOfPackageRLP = "github.com/tenderly/op-geth/rlp"
func main() {
var (
diff --git go-ethereum/rlp/rlpgen/testdata/bigint.out.txt op-geth/rlp/rlpgen/testdata/bigint.out.txt
index f54d1faa15f733f5f94c236d908c7e141f07beb5..24e11219fdb38363d05e44d9ce1ccde20d555949 100644
--- go-ethereum/rlp/rlpgen/testdata/bigint.out.txt
+++ op-geth/rlp/rlpgen/testdata/bigint.out.txt
@@ -1,6 +1,6 @@
package test
-import "github.com/ethereum/go-ethereum/rlp"
+import "github.com/tenderly/op-geth/rlp"
import "io"
func (obj *Test) EncodeRLP(_w io.Writer) error {
diff --git go-ethereum/rlp/rlpgen/testdata/nil.out.txt op-geth/rlp/rlpgen/testdata/nil.out.txt
index e0d5dcebad3bdb4d096d111ee18fd89567b7677b..00890f466e54860de9368141546588092f3beeba 100644
--- go-ethereum/rlp/rlpgen/testdata/nil.out.txt
+++ op-geth/rlp/rlpgen/testdata/nil.out.txt
@@ -1,6 +1,6 @@
package test
-import "github.com/ethereum/go-ethereum/rlp"
+import "github.com/tenderly/op-geth/rlp"
import "io"
func (obj *Test) EncodeRLP(_w io.Writer) error {
diff --git go-ethereum/rlp/rlpgen/testdata/optional.out.txt op-geth/rlp/rlpgen/testdata/optional.out.txt
index 02df8e457f94f84d5d0e4efceb6bb4e815449d82..7101149295f59194e67841fc3eaa4404996f3b46 100644
--- go-ethereum/rlp/rlpgen/testdata/optional.out.txt
+++ op-geth/rlp/rlpgen/testdata/optional.out.txt
@@ -1,6 +1,6 @@
package test
-import "github.com/ethereum/go-ethereum/rlp"
+import "github.com/tenderly/op-geth/rlp"
import "io"
func (obj *Test) EncodeRLP(_w io.Writer) error {
diff --git go-ethereum/rlp/rlpgen/testdata/rawvalue.in.txt op-geth/rlp/rlpgen/testdata/rawvalue.in.txt
index 3a657bc907bb27dbd2faa11010a222748e07080e..6f8cd3a6b7c316b7efe891cb19e73a3e41aa1103 100644
--- go-ethereum/rlp/rlpgen/testdata/rawvalue.in.txt
+++ op-geth/rlp/rlpgen/testdata/rawvalue.in.txt
@@ -2,7 +2,7 @@ // -*- mode: go -*-
package test
-import "github.com/ethereum/go-ethereum/rlp"
+import "github.com/tenderly/op-geth/rlp"
type Test struct {
RawValue rlp.RawValue
diff --git go-ethereum/rlp/rlpgen/testdata/rawvalue.out.txt op-geth/rlp/rlpgen/testdata/rawvalue.out.txt
index 3607c9863676ea427f9517a9ed6f6ee956ee0819..400b4c970bec9228cc6c1216343accc5279cb984 100644
--- go-ethereum/rlp/rlpgen/testdata/rawvalue.out.txt
+++ op-geth/rlp/rlpgen/testdata/rawvalue.out.txt
@@ -1,6 +1,6 @@
package test
-import "github.com/ethereum/go-ethereum/rlp"
+import "github.com/tenderly/op-geth/rlp"
import "io"
func (obj *Test) EncodeRLP(_w io.Writer) error {
diff --git go-ethereum/rlp/rlpgen/testdata/uint256.out.txt op-geth/rlp/rlpgen/testdata/uint256.out.txt
index 5e6d3ed992cdbe5b00bf439a493d647330b73c69..e17d4b44ea6652ffaad83f323be4e1a82e095228 100644
--- go-ethereum/rlp/rlpgen/testdata/uint256.out.txt
+++ op-geth/rlp/rlpgen/testdata/uint256.out.txt
@@ -1,6 +1,6 @@
package test
-import "github.com/ethereum/go-ethereum/rlp"
+import "github.com/tenderly/op-geth/rlp"
import "github.com/holiman/uint256"
import "io"
diff --git go-ethereum/rlp/rlpgen/testdata/uints.out.txt op-geth/rlp/rlpgen/testdata/uints.out.txt
index 1a354956a4094ec408541f672fca4c9f439ba0e6..659e52ebeb6174eea9b668c9131364e161426134 100644
--- go-ethereum/rlp/rlpgen/testdata/uints.out.txt
+++ op-geth/rlp/rlpgen/testdata/uints.out.txt
@@ -1,6 +1,6 @@
package test
-import "github.com/ethereum/go-ethereum/rlp"
+import "github.com/tenderly/op-geth/rlp"
import "io"
func (obj *Test) EncodeRLP(_w io.Writer) error {
diff --git go-ethereum/rlp/typecache.go op-geth/rlp/typecache.go
index 3e37c9d2fcc70e1490abca072565ac126c0ea7f1..f70d5c08afc3b126e5fc31f4d551e67f9ccad074 100644
--- go-ethereum/rlp/typecache.go
+++ op-geth/rlp/typecache.go
@@ -22,7 +22,7 @@ "reflect"
"sync"
"sync/atomic"
- "github.com/ethereum/go-ethereum/rlp/internal/rlpstruct"
+ "github.com/tenderly/op-geth/rlp/internal/rlpstruct"
)
// typeinfo is an entry in the type cache.
diff --git go-ethereum/rpc/client.go op-geth/rpc/client.go
index 2b0016db8f4ec2e9d33cf937efe2dde42a3ffa6a..63d0550c0cef0e464a0d0aa6a8d5b99c45dad4ec 100644
--- go-ethereum/rpc/client.go
+++ op-geth/rpc/client.go
@@ -28,7 +28,7 @@ "strconv"
"sync/atomic"
"time"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
var (
diff --git go-ethereum/rpc/doc.go op-geth/rpc/doc.go
index 7c87793dcab6d901c702302ed455dda3fdc94733..b7b1b79c040eefac0e1324dd987fa985474b5b33 100644
--- go-ethereum/rpc/doc.go
+++ op-geth/rpc/doc.go
@@ -98,7 +98,7 @@ Subscriptions are deleted when the user sends an unsubscribe request or when the
connection which was used to create the subscription is closed. This can be initiated by
the client and server. The server will close the connection for any write error.
-For more information about subscriptions, see https://github.com/ethereum/go-ethereum/wiki/RPC-PUB-SUB.
+For more information about subscriptions, see https://github.com/tenderly/op-geth/wiki/RPC-PUB-SUB.
# Reverse Calls
diff --git go-ethereum/rpc/endpoints.go op-geth/rpc/endpoints.go
index d78ebe2858bceddaefc3e7d745e8b8ff972c0560..e395d3467dea5cf3d5d8bec1e6fd4ccfcc9c0f5a 100644
--- go-ethereum/rpc/endpoints.go
+++ op-geth/rpc/endpoints.go
@@ -20,7 +20,7 @@ import (
"net"
"strings"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
// StartIPCEndpoint starts an IPC endpoint.
diff --git go-ethereum/rpc/handler.go op-geth/rpc/handler.go
index f44e4d7b01d89976903e5da98e30ea1e78ebfe6c..3c239a88909c24e4f2262d53b9f163ecaa3439d0 100644
--- go-ethereum/rpc/handler.go
+++ op-geth/rpc/handler.go
@@ -25,7 +25,7 @@ "strings"
"sync"
"time"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
// handler handles JSON-RPC messages. There is one handler per connection. Note that
diff --git go-ethereum/rpc/http.go op-geth/rpc/http.go
index dd376b1ecd59834fa99f0c3329fc146229b366b1..d79ac462d146c6924c06d5e3e9e6a2d75b97da59 100644
--- go-ethereum/rpc/http.go
+++ op-geth/rpc/http.go
@@ -33,8 +33,9 @@ "time"
)
const (
- defaultBodyLimit = 5 * 1024 * 1024
- contentType = "application/json"
+ maxRequestContentLength = 1024 * 1024 * 32
+ defaultBodyLimit = 5 * 1024 * 1024
+ contentType = "application/json"
)
// https://www.jsonrpc.org/historical/json-rpc-over-http.html#id13
diff --git go-ethereum/rpc/ipc.go op-geth/rpc/ipc.go
index a08245b270891503b72d70ae7faec6052c254960..92c05ed1d89bfa877175a4ed96d4d3e3cac1a432 100644
--- go-ethereum/rpc/ipc.go
+++ op-geth/rpc/ipc.go
@@ -20,8 +20,8 @@ import (
"context"
"net"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/p2p/netutil"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/p2p/netutil"
)
// ServeListener accepts connections on l, serving JSON-RPC on them.
diff --git go-ethereum/rpc/ipc_unix.go op-geth/rpc/ipc_unix.go
index 33c1cad5494ac91975acd314f654b0fb839c5463..429ef8ff9fff88b1316bf8d63f7d03877a3ea1ab 100644
--- go-ethereum/rpc/ipc_unix.go
+++ op-geth/rpc/ipc_unix.go
@@ -26,7 +26,7 @@ "net"
"os"
"path/filepath"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
const (
diff --git go-ethereum/rpc/metrics.go op-geth/rpc/metrics.go
index ef7449ce05e28d828a24870e97a03a5d43c5ee01..44edb9859c9f68352970a67f3efe9b0a8765f4a6 100644
--- go-ethereum/rpc/metrics.go
+++ op-geth/rpc/metrics.go
@@ -20,7 +20,7 @@ import (
"fmt"
"time"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/metrics"
)
var (
diff --git go-ethereum/rpc/server.go op-geth/rpc/server.go
index e2f9120aa2bcec35680346286d454579e6fa37a7..a3985ce385a9d56ffac81357aee9f34bdfdaa325 100644
--- go-ethereum/rpc/server.go
+++ op-geth/rpc/server.go
@@ -22,7 +22,7 @@ "io"
"sync"
"sync/atomic"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
const MetadataApi = "rpc"
diff --git go-ethereum/rpc/service.go op-geth/rpc/service.go
index a180b8db93e23d5d3c5eed982ecdbfce42de65ac..de4e2aefba3841233182f41723d19bb4a070706b 100644
--- go-ethereum/rpc/service.go
+++ op-geth/rpc/service.go
@@ -25,7 +25,7 @@ "strings"
"sync"
"unicode"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
var (
diff --git go-ethereum/rpc/types.go op-geth/rpc/types.go
index d124081786154f77c4f25bf0d02c07a0237c85c0..dddf953a5edd818deeeb296f7da9790b2494615d 100644
--- go-ethereum/rpc/types.go
+++ op-geth/rpc/types.go
@@ -24,8 +24,8 @@ "fmt"
"math"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
// API describes the set of methods offered over the RPC interface
diff --git go-ethereum/rpc/websocket.go op-geth/rpc/websocket.go
index 538e53a31b7c363af28b6ec862ed163cbea05ed5..c9549a7f97b338bb355bb019b89498cb9fbab9f8 100644
--- go-ethereum/rpc/websocket.go
+++ op-geth/rpc/websocket.go
@@ -28,8 +28,8 @@ "sync"
"time"
mapset "github.com/deckarep/golang-set/v2"
- "github.com/ethereum/go-ethereum/log"
"github.com/gorilla/websocket"
+ "github.com/tenderly/op-geth/log"
)
const (
diff --git go-ethereum/signer/core/api.go op-geth/signer/core/api.go
index a32f24cb18c492122295e37b3d3d3b7ce936f6fb..6e470efc0a330ee6914c80f8f190d204cfe87d70 100644
--- go-ethereum/signer/core/api.go
+++ op-geth/signer/core/api.go
@@ -26,18 +26,18 @@ "math/big"
"os"
"reflect"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/accounts/scwallet"
- "github.com/ethereum/go-ethereum/accounts/usbwallet"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
- "github.com/ethereum/go-ethereum/signer/storage"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/accounts/scwallet"
+ "github.com/tenderly/op-geth/accounts/usbwallet"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rpc"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
+ "github.com/tenderly/op-geth/signer/storage"
)
const (
diff --git go-ethereum/signer/core/apitypes/types.go op-geth/signer/core/apitypes/types.go
index 6bfcd2a727b4730fb51a11a0ebe24bbc501182a0..96a27251322d04d4476e3d65f612d230d71911eb 100644
--- go-ethereum/signer/core/apitypes/types.go
+++ op-geth/signer/core/apitypes/types.go
@@ -28,12 +28,12 @@ "sort"
"strconv"
"strings"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
)
var typedDataReferenceTypeRegexp = regexp.MustCompile(`^[A-Za-z](\w*)(\[\])?$`)
@@ -91,7 +91,7 @@ Nonce hexutil.Uint64 `json:"nonce"`
// We accept "data" and "input" for backwards-compatibility reasons.
// "input" is the newer name and should be preferred by clients.
- // Issue detail: https://github.com/ethereum/go-ethereum/issues/15628
+ // Issue detail: https://github.com/tenderly/op-geth/issues/15628
Data *hexutil.Bytes `json:"data"`
Input *hexutil.Bytes `json:"input,omitempty"`
diff --git go-ethereum/signer/core/auditlog.go op-geth/signer/core/auditlog.go
index d2207c9eb8d5df25abeb5bb88007cc6d589d8ccf..f2c4af1cd7a8e4f8724d7875a1f8868d6c1aedbb 100644
--- go-ethereum/signer/core/auditlog.go
+++ op-geth/signer/core/auditlog.go
@@ -21,11 +21,11 @@ "context"
"encoding/json"
"os"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
"golang.org/x/exp/slog"
)
diff --git go-ethereum/signer/core/cliui.go op-geth/signer/core/cliui.go
index b1bd3206ed3f6c3b41bb38bdb8e3487514fac3d5..e394ea56eb0be4fa4d019b9e58fdb0d2719c6af7 100644
--- go-ethereum/signer/core/cliui.go
+++ op-geth/signer/core/cliui.go
@@ -25,10 +25,10 @@ "os"
"strings"
"sync"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/console/prompt"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/console/prompt"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/log"
)
type CommandlineUI struct {
diff --git go-ethereum/signer/core/gnosis_safe.go op-geth/signer/core/gnosis_safe.go
index 01724e53836ca6723d11ea9af449fa04e88df76f..a4f5c0c850b75c2f135982648ad2ebc6835c341c 100644
--- go-ethereum/signer/core/gnosis_safe.go
+++ op-geth/signer/core/gnosis_safe.go
@@ -20,10 +20,10 @@ import (
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
)
// GnosisSafeTx is a type to parse the safe-tx returned by the relayer,
diff --git go-ethereum/signer/core/signed_data.go op-geth/signer/core/signed_data.go
index c6ae7b12743f3d85df44364a0a0d0aa80484b0c8..c911866d99187c39c084a0cc5afc404e24fd5f33 100644
--- go-ethereum/signer/core/signed_data.go
+++ op-geth/signer/core/signed_data.go
@@ -23,14 +23,14 @@ "errors"
"fmt"
"mime"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/consensus/clique"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/consensus/clique"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
)
// sign receives a request and produces a signature
diff --git go-ethereum/signer/core/stdioui.go op-geth/signer/core/stdioui.go
index a0ce6844171f9021f72029b0529528b3efaab4f2..26cb095a96134fa8d3888927641360640446d56c 100644
--- go-ethereum/signer/core/stdioui.go
+++ op-geth/signer/core/stdioui.go
@@ -19,9 +19,9 @@
import (
"context"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rpc"
)
type StdIOUI struct {
diff --git go-ethereum/signer/core/uiapi.go op-geth/signer/core/uiapi.go
index b8c3acfb4d31c40c54f3a95a8714707150e7991a..b2029d5bd74fc1460cce54812b55fe2b7d526036 100644
--- go-ethereum/signer/core/uiapi.go
+++ op-geth/signer/core/uiapi.go
@@ -24,11 +24,11 @@ "fmt"
"math/big"
"os"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/keystore"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
+ "github.com/tenderly/op-geth/accounts"
+ "github.com/tenderly/op-geth/accounts/keystore"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/crypto"
)
// UIServerAPI implements methods Clef provides for a UI to query, in the bidirectional communication
diff --git go-ethereum/signer/fourbyte/abi.go op-geth/signer/fourbyte/abi.go
index 352abc59e18214e64eca22d0381d93ea4e432407..16aef67fe65bc6771aceaebcd64016f3000c8317 100644
--- go-ethereum/signer/fourbyte/abi.go
+++ op-geth/signer/fourbyte/abi.go
@@ -22,8 +22,8 @@ "encoding/json"
"fmt"
"strings"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/accounts/abi"
+ "github.com/tenderly/op-geth/common"
)
// decodedCallData is an internal type to represent a method call parsed according
diff --git go-ethereum/signer/fourbyte/validation.go op-geth/signer/fourbyte/validation.go
index 58111e8e00c82adbf19667805cda1c27ac5482f1..8572cc9d3b8890d2eb9080f8ab2f1ae591bcf5cc 100644
--- go-ethereum/signer/fourbyte/validation.go
+++ op-geth/signer/fourbyte/validation.go
@@ -22,8 +22,8 @@ "errors"
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/signer/core/apitypes"
)
// ValidateTransaction does a number of checks on the supplied transaction, and
@@ -49,7 +49,7 @@ // Contract creation doesn't validate call data, handle first
if tx.To == nil {
// Contract creation should contain sufficient data to deploy a contract. A
// typical error is omitting sender due to some quirk in the javascript call
- // e.g. https://github.com/ethereum/go-ethereum/issues/16106.
+ // e.g. https://github.com/tenderly/op-geth/issues/16106.
if len(data) == 0 {
// Prevent sending ether into black hole (show stopper)
if tx.Value.ToInt().Cmp(big.NewInt(0)) > 0 {
diff --git go-ethereum/signer/rules/rules.go op-geth/signer/rules/rules.go
index c9921e57a9581141f2a358283c0678624e766540..cd866def045f3fd72936732a066f33ef6066cc21 100644
--- go-ethereum/signer/rules/rules.go
+++ op-geth/signer/rules/rules.go
@@ -24,11 +24,11 @@ "os"
"strings"
"github.com/dop251/goja"
- "github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/internal/jsre/deps"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/signer/core"
- "github.com/ethereum/go-ethereum/signer/storage"
+ "github.com/tenderly/op-geth/internal/ethapi"
+ "github.com/tenderly/op-geth/internal/jsre/deps"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/signer/core"
+ "github.com/tenderly/op-geth/signer/storage"
)
// consoleOutput is an override for the console.log and console.error methods to
diff --git go-ethereum/signer/storage/aes_gcm_storage.go op-geth/signer/storage/aes_gcm_storage.go
index 928d643dd618b7b5c6318f2dca2e2bb7e73d39b1..fc40f5633d1076a3ae1c92fcdb8823bdcec90d91 100644
--- go-ethereum/signer/storage/aes_gcm_storage.go
+++ op-geth/signer/storage/aes_gcm_storage.go
@@ -24,7 +24,7 @@ "encoding/json"
"io"
"os"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/log"
)
type storedCredential struct {
diff --git go-ethereum/tests/block_test_util.go op-geth/tests/block_test_util.go
index 53d733f1c44dbb75acd6d26062b46fac266be8e4..c229d4aa220e2e10c35aa0ddff22f5bfb966f0b4 100644
--- go-ethereum/tests/block_test_util.go
+++ op-geth/tests/block_test_util.go
@@ -26,22 +26,22 @@ "math/big"
"os"
"reflect"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus/beacon"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/hashdb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus/beacon"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/hashdb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
)
// A BlockTest checks handling of entire blocks.
diff --git go-ethereum/tests/difficulty_test_util.go op-geth/tests/difficulty_test_util.go
index 62b978f9ef2b08424eaa4d3e4a7d4e3d39666d17..1531ad93e5cec8ab7dcc26456ea7bfc0338a133b 100644
--- go-ethereum/tests/difficulty_test_util.go
+++ op-geth/tests/difficulty_test_util.go
@@ -20,11 +20,11 @@ import (
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
)
//go:generate go run github.com/fjl/gencodec -type DifficultyTest -field-override difficultyTestMarshaling -out gen_difficultytest.go
diff --git go-ethereum/tests/fuzzers/bls12381/bls12381_fuzz.go op-geth/tests/fuzzers/bls12381/bls12381_fuzz.go
index 9a5c566540f75317106a5da4be88b54a46c11a19..c7f0def7537273554c1557af510c0a9f9969f1dd 100644
--- go-ethereum/tests/fuzzers/bls12381/bls12381_fuzz.go
+++ op-geth/tests/fuzzers/bls12381/bls12381_fuzz.go
@@ -30,9 +30,9 @@ "github.com/consensys/gnark-crypto/ecc"
gnark "github.com/consensys/gnark-crypto/ecc/bls12-381"
"github.com/consensys/gnark-crypto/ecc/bls12-381/fp"
"github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto/bls12381"
blst "github.com/supranational/blst/bindings/go"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto/bls12381"
)
func fuzzCrossPairing(data []byte) int {
diff --git go-ethereum/tests/fuzzers/bls12381/precompile_fuzzer.go op-geth/tests/fuzzers/bls12381/precompile_fuzzer.go
index 763ed56e9f7acc6be4c092796cd9dd6fbf4c40a9..77bff87810fc6a9362dd22b1d8ca7b02a78030a1 100644
--- go-ethereum/tests/fuzzers/bls12381/precompile_fuzzer.go
+++ op-geth/tests/fuzzers/bls12381/precompile_fuzzer.go
@@ -20,8 +20,8 @@ import (
"bytes"
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/vm"
)
const (
diff --git go-ethereum/tests/fuzzers/bn256/bn256_fuzz.go op-geth/tests/fuzzers/bn256/bn256_fuzz.go
index 75f7d59deeef7bdcb8ebbad98a55e299e0d33cef..4aa1481ff8d51dc4f9c73f2cb98e3a75fd731347 100644
--- go-ethereum/tests/fuzzers/bn256/bn256_fuzz.go
+++ op-geth/tests/fuzzers/bn256/bn256_fuzz.go
@@ -23,8 +23,8 @@ "io"
"math/big"
"github.com/consensys/gnark-crypto/ecc/bn254"
- cloudflare "github.com/ethereum/go-ethereum/crypto/bn256/cloudflare"
- google "github.com/ethereum/go-ethereum/crypto/bn256/google"
+ cloudflare "github.com/tenderly/op-geth/crypto/bn256/cloudflare"
+ google "github.com/tenderly/op-geth/crypto/bn256/google"
)
func getG1Points(input io.Reader) (*cloudflare.G1, *google.G1, *bn254.G1Affine) {
diff --git go-ethereum/tests/fuzzers/difficulty/difficulty-fuzz.go op-geth/tests/fuzzers/difficulty/difficulty-fuzz.go
index fbbd7f6876baf21262887ea37853808068237ab1..c7e55f52ca0c64207014a1e0665ef74d18cf09a5 100644
--- go-ethereum/tests/fuzzers/difficulty/difficulty-fuzz.go
+++ op-geth/tests/fuzzers/difficulty/difficulty-fuzz.go
@@ -23,8 +23,8 @@ "fmt"
"io"
"math/big"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/consensus/ethash"
+ "github.com/tenderly/op-geth/core/types"
)
type fuzzer struct {
diff --git go-ethereum/tests/fuzzers/rangeproof/rangeproof-fuzzer.go op-geth/tests/fuzzers/rangeproof/rangeproof-fuzzer.go
index dcafebb265d5a45498afe7019e5caab5d3246d04..ab08e1cedb4f3357090d83d5649725d453109f50 100644
--- go-ethereum/tests/fuzzers/rangeproof/rangeproof-fuzzer.go
+++ op-geth/tests/fuzzers/rangeproof/rangeproof-fuzzer.go
@@ -22,11 +22,11 @@ "encoding/binary"
"fmt"
"io"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb/memorydb"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/triedb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb/memorydb"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/triedb"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/tests/fuzzers/txfetcher/txfetcher_fuzzer.go op-geth/tests/fuzzers/txfetcher/txfetcher_fuzzer.go
index 51f2fc3b4d97d64c9cb65251bce2633e23446fb2..452f63ccfc2fe9196b72c4fdc38dc3fcc7dae0d6 100644
--- go-ethereum/tests/fuzzers/txfetcher/txfetcher_fuzzer.go
+++ op-geth/tests/fuzzers/txfetcher/txfetcher_fuzzer.go
@@ -23,10 +23,10 @@ "math/big"
"math/rand"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/eth/fetcher"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/mclock"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/eth/fetcher"
)
var (
diff --git go-ethereum/tests/gen_btheader.go op-geth/tests/gen_btheader.go
index 80ad89e03bf548393b01102e0687c11940b8f268..b960a0b8961f4051ec41b9cd128a8386f3992bf9 100644
--- go-ethereum/tests/gen_btheader.go
+++ op-geth/tests/gen_btheader.go
@@ -6,10 +6,10 @@ import (
"encoding/json"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/types"
)
var _ = (*btHeaderMarshaling)(nil)
diff --git go-ethereum/tests/gen_difficultytest.go op-geth/tests/gen_difficultytest.go
index cd15ae31b5d311f90e613884d65a5511dfcc2c3c..75075709a06811288f77cca02391624d11e8a43b 100644
--- go-ethereum/tests/gen_difficultytest.go
+++ op-geth/tests/gen_difficultytest.go
@@ -6,8 +6,8 @@ import (
"encoding/json"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
)
var _ = (*difficultyTestMarshaling)(nil)
diff --git go-ethereum/tests/gen_stenv.go op-geth/tests/gen_stenv.go
index a5bd0d5fcb8e2fc8a9aaf7d9894d4c8118407b38..6e1755e65e0476c993a1b1e7decbeb7527809c33 100644
--- go-ethereum/tests/gen_stenv.go
+++ op-geth/tests/gen_stenv.go
@@ -7,8 +7,8 @@ "encoding/json"
"errors"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/math"
)
var _ = (*stEnvMarshaling)(nil)
diff --git go-ethereum/tests/gen_sttransaction.go op-geth/tests/gen_sttransaction.go
index 9b5aecbfe6b81db8c4eb73f366729c077293114c..06e337ba8268b46f95083a802ac3e1c2dbbaea1e 100644
--- go-ethereum/tests/gen_sttransaction.go
+++ op-geth/tests/gen_sttransaction.go
@@ -6,10 +6,10 @@ import (
"encoding/json"
"math/big"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/core/types"
)
var _ = (*stTransactionMarshaling)(nil)
diff --git go-ethereum/tests/init.go op-geth/tests/init.go
index 99b7e4d33310197abddec8960d869f61818bb20b..0af50bd60eaf8c8ed06695fa2144bd091db3f1cf 100644
--- go-ethereum/tests/init.go
+++ op-geth/tests/init.go
@@ -21,7 +21,7 @@ "fmt"
"math/big"
"sort"
- "github.com/ethereum/go-ethereum/params"
+ "github.com/tenderly/op-geth/params"
)
func u64(val uint64) *uint64 { return &val }
diff --git go-ethereum/tests/rlp_test_util.go op-geth/tests/rlp_test_util.go
index e4bd5450a845864e2e79e3e74db9a940fe08e621..d1a578ad164d3165a36c34d1daf558f634b05885 100644
--- go-ethereum/tests/rlp_test_util.go
+++ op-geth/tests/rlp_test_util.go
@@ -24,7 +24,7 @@ "fmt"
"math/big"
"strings"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/rlp"
)
// RLPTest is the JSON structure of a single RLP test.
diff --git go-ethereum/tests/state_test_util.go op-geth/tests/state_test_util.go
index c916d26d412aa2659f9cb0758c9c3edce73fdd1f..26e4cbc55bdd5689a8b25b259c16e51285055c2e 100644
--- go-ethereum/tests/state_test_util.go
+++ op-geth/tests/state_test_util.go
@@ -25,24 +25,24 @@ "math/big"
"strconv"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/state"
- "github.com/ethereum/go-ethereum/core/state/snapshot"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/triedb"
- "github.com/ethereum/go-ethereum/triedb/hashdb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/common/math"
+ "github.com/tenderly/op-geth/consensus/misc/eip4844"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/state"
+ "github.com/tenderly/op-geth/core/state/snapshot"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/core/vm"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/triedb"
+ "github.com/tenderly/op-geth/triedb/hashdb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
"golang.org/x/crypto/sha3"
)
@@ -277,7 +277,7 @@ }
// Prepare the EVM.
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(block.Header(), nil, &t.json.Env.Coinbase)
+ context := core.NewEVMBlockContext(block.Header(), nil, &t.json.Env.Coinbase, config, state.StateDB)
context.GetHash = vmTestBlockHash
context.BaseFee = baseFee
context.Random = nil
diff --git go-ethereum/tests/transaction_test_util.go op-geth/tests/transaction_test_util.go
index 391aa57584cfa5708234d2ff5fe4f8d7875afe34..15af2dfc1435c0c156552781f4ae0e323f57c582 100644
--- go-ethereum/tests/transaction_test_util.go
+++ op-geth/tests/transaction_test_util.go
@@ -19,12 +19,12 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
+ "github.com/tenderly/op-geth/core"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/rlp"
)
// TransactionTest checks RLP decoding and sender derivation of transactions.
diff --git go-ethereum/trie/committer.go op-geth/trie/committer.go
index 4e2f7b8bd6a33cead500f01f731704f13a02474b..72d4d0a5975ae195554115ce62aff06248306b84 100644
--- go-ethereum/trie/committer.go
+++ op-geth/trie/committer.go
@@ -19,8 +19,8 @@
import (
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/trie/trienode"
)
// committer is the tool used for the trie Commit operation. The committer will
diff --git go-ethereum/trie/errors.go op-geth/trie/errors.go
index 7be7041c7f0978ebc6fe3964bade380e174a1444..e3bff760185b083b5e2077fc28836363215094a0 100644
--- go-ethereum/trie/errors.go
+++ op-geth/trie/errors.go
@@ -20,7 +20,7 @@ import (
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// ErrCommitted is returned when a already committed trie is requested for usage.
diff --git go-ethereum/trie/hasher.go op-geth/trie/hasher.go
index 1e063d8020b94b93653ad52128a79d1dcffb1632..db4fd5c847d630246739544f09dd284ab9aa5222 100644
--- go-ethereum/trie/hasher.go
+++ op-geth/trie/hasher.go
@@ -19,8 +19,8 @@
import (
"sync"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/trie/iterator.go op-geth/trie/iterator.go
index 83ccc0740f3a31d86edaeab252f1006b317b9210..d9e16ef2fab812923a07783f0acb4fed0826335a 100644
--- go-ethereum/trie/iterator.go
+++ op-geth/trie/iterator.go
@@ -21,8 +21,8 @@ "bytes"
"container/heap"
"errors"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
)
// NodeResolver is used for looking up trie nodes before reaching into the real
diff --git go-ethereum/trie/node.go op-geth/trie/node.go
index 15bbf62f1c9327586f8a3f5cb9a2e503a387ac96..80414c5c01680c60817d9827a8e4584cd65d25a7 100644
--- go-ethereum/trie/node.go
+++ op-geth/trie/node.go
@@ -21,8 +21,8 @@ "fmt"
"io"
"strings"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/rlp"
)
var indices = []string{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "[17]"}
diff --git go-ethereum/trie/node_enc.go op-geth/trie/node_enc.go
index 1b2eca682f0b0c4d6a58a394c198cd9656456cad..71757e5e1015d3b7f260d5d59c04476179062784 100644
--- go-ethereum/trie/node_enc.go
+++ op-geth/trie/node_enc.go
@@ -17,7 +17,7 @@
package trie
import (
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/rlp"
)
func nodeToBytes(n node) []byte {
diff --git go-ethereum/trie/proof.go op-geth/trie/proof.go
index fd892fb4becb9eef64548dc15736325d808f102f..a883fd31704e2f928f27a7cd82d94ab799782398 100644
--- go-ethereum/trie/proof.go
+++ op-geth/trie/proof.go
@@ -21,9 +21,9 @@ "bytes"
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
)
// Prove constructs a merkle proof for key. The result contains all encoded nodes
diff --git go-ethereum/trie/secure_trie.go op-geth/trie/secure_trie.go
index efd4dfb5d33fb55c7d220e43772d7ef2f4a27f40..5602d6b6b1f3df5a261071667bb7eaf21c9cf6a1 100644
--- go-ethereum/trie/secure_trie.go
+++ op-geth/trie/secure_trie.go
@@ -17,11 +17,11 @@
package trie
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/triedb/database"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/triedb/database"
)
// SecureTrie is the old name of StateTrie.
diff --git go-ethereum/trie/stacktrie.go op-geth/trie/stacktrie.go
index 9c574db0bfa5fbbc9eea1eb01fd06ee88be2fb67..8304cf4c2dfd0efb9bfc346cc48dc89909cb237d 100644
--- go-ethereum/trie/stacktrie.go
+++ op-geth/trie/stacktrie.go
@@ -21,8 +21,8 @@ "bytes"
"errors"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
)
var (
diff --git go-ethereum/trie/sync.go op-geth/trie/sync.go
index 589d28364b879897971759381b48c9a253083726..4daa9d7488c7efcec1d9e93178b3d00ebf4a0a67 100644
--- go-ethereum/trie/sync.go
+++ op-geth/trie/sync.go
@@ -21,13 +21,13 @@ "errors"
"fmt"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/prque"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/prque"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
)
// ErrNotRequested is returned by the trie sync when it's requested to process a
diff --git go-ethereum/trie/testutil/utils.go op-geth/trie/testutil/utils.go
index a75d0431b0f4660a595c244fd0c1cb72ea530547..70b3a6659bbd13e707d192be098813bbd4aaa847 100644
--- go-ethereum/trie/testutil/utils.go
+++ op-geth/trie/testutil/utils.go
@@ -21,9 +21,9 @@ crand "crypto/rand"
"encoding/binary"
mrand "math/rand"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/trie/trienode"
)
// Prng is a pseudo random number generator seeded by strong randomness.
diff --git go-ethereum/trie/tracer.go op-geth/trie/tracer.go
index 5786af4d3ec950e3f698ec55d5366dc7b3119020..f1497948190d248cfade3a14aad53e43dc87fc53 100644
--- go-ethereum/trie/tracer.go
+++ op-geth/trie/tracer.go
@@ -17,7 +17,7 @@
package trie
import (
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// tracer tracks the changes of trie nodes. During the trie operations,
diff --git go-ethereum/trie/trie.go op-geth/trie/trie.go
index 12764e18d1b077530914c6398d35db7e9290b5b2..04ac008d86b50f9174baac9c428e4880b2433a9d 100644
--- go-ethereum/trie/trie.go
+++ op-geth/trie/trie.go
@@ -22,11 +22,11 @@ "bytes"
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/triedb/database"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/triedb/database"
)
// Trie is a Merkle Patricia Trie. Use New to create a trie that sits on
diff --git go-ethereum/trie/trie_id.go op-geth/trie/trie_id.go
index 8ab490ca3b1ccf81267fb588f873346d0d0240b9..fc3938fb15e6c8560ad06032aebfbf5f122c1032 100644
--- go-ethereum/trie/trie_id.go
+++ op-geth/trie/trie_id.go
@@ -16,7 +16,7 @@ // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>
package trie
-import "github.com/ethereum/go-ethereum/common"
+import "github.com/tenderly/op-geth/common"
// ID is the identifier for uniquely identifying a trie.
type ID struct {
diff --git go-ethereum/trie/trie_reader.go op-geth/trie/trie_reader.go
index 42bc4316fe63aad35da04027f6e548955d1e1b23..55fe8bcae0030fe570e2cda5f735195c538d5436 100644
--- go-ethereum/trie/trie_reader.go
+++ op-geth/trie/trie_reader.go
@@ -17,11 +17,11 @@
package trie
import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/trie/triestate"
- "github.com/ethereum/go-ethereum/triedb/database"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/trie/triestate"
+ "github.com/tenderly/op-geth/triedb/database"
)
// trieReader is a wrapper of the underlying node reader. It's not safe
diff --git go-ethereum/trie/trienode/node.go op-geth/trie/trienode/node.go
index 95315c2e9a4f2601dd42389082e726afe570a338..8aeea7e3c6c5a0dcf968f620cbba4583033919c0 100644
--- go-ethereum/trie/trienode/node.go
+++ op-geth/trie/trienode/node.go
@@ -21,7 +21,7 @@ "fmt"
"sort"
"strings"
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// Node is a wrapper which contains the encoded blob of the trie node and its
diff --git go-ethereum/trie/trienode/proof.go op-geth/trie/trienode/proof.go
index 012f0087dded262bea272f84e71c4c5c0af7337b..9ea84be319936ead6c9a0deb268e8aac72755731 100644
--- go-ethereum/trie/trienode/proof.go
+++ op-geth/trie/trienode/proof.go
@@ -20,10 +20,10 @@ import (
"errors"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/rlp"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/rlp"
)
// ProofSet stores a set of trie nodes. It implements trie.Database and can also
diff --git go-ethereum/trie/triestate/state.go op-geth/trie/triestate/state.go
index 4c47e9c3973495ed881c75315a2f011b3bcfef6c..dfd6c2b1ce7efd48ac2cab33d56e5c978e5405b3 100644
--- go-ethereum/trie/triestate/state.go
+++ op-geth/trie/triestate/state.go
@@ -21,11 +21,11 @@ "errors"
"fmt"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie/trienode"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/trie/utils/verkle.go op-geth/trie/utils/verkle.go
index ce059edc64380e0c9faf919e1e1377ffc0fa149b..2151f1730ead9c7aeaca82082280956e3cc33af1 100644
--- go-ethereum/trie/utils/verkle.go
+++ op-geth/trie/utils/verkle.go
@@ -21,10 +21,10 @@ "encoding/binary"
"sync"
"github.com/crate-crypto/go-ipa/bandersnatch/fr"
- "github.com/ethereum/go-ethereum/common/lru"
- "github.com/ethereum/go-ethereum/metrics"
"github.com/gballet/go-verkle"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common/lru"
+ "github.com/tenderly/op-geth/metrics"
)
const (
diff --git go-ethereum/trie/verkle.go op-geth/trie/verkle.go
index 01d813d9ec9ba9b36f1054dab2d2e5433e59d302..b29a3598e6657265e954a1698120791a5edf22ad 100644
--- go-ethereum/trie/verkle.go
+++ op-geth/trie/verkle.go
@@ -21,14 +21,14 @@ "encoding/binary"
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/utils"
- "github.com/ethereum/go-ethereum/triedb/database"
"github.com/gballet/go-verkle"
"github.com/holiman/uint256"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/utils"
+ "github.com/tenderly/op-geth/triedb/database"
)
var (
diff --git go-ethereum/triedb/database.go op-geth/triedb/database.go
index 939a21f1478b0b44a8ac86beb8db2a84912b35c8..495cd04e8365cb639ff574bc6f55907518281bc7 100644
--- go-ethereum/triedb/database.go
+++ op-geth/triedb/database.go
@@ -19,15 +19,15 @@
import (
"errors"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/trie"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/triestate"
- "github.com/ethereum/go-ethereum/triedb/database"
- "github.com/ethereum/go-ethereum/triedb/hashdb"
- "github.com/ethereum/go-ethereum/triedb/pathdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/trie"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/triestate"
+ "github.com/tenderly/op-geth/triedb/database"
+ "github.com/tenderly/op-geth/triedb/hashdb"
+ "github.com/tenderly/op-geth/triedb/pathdb"
)
// Config defines all necessary options for database.
diff --git go-ethereum/triedb/database/database.go op-geth/triedb/database/database.go
index 18a8f454e2f4cf7c6896e98b37dd1ab7d7f1f4f6..bf4bf1fa1b25c2d41416da41e45955d277a72ee8 100644
--- go-ethereum/triedb/database/database.go
+++ op-geth/triedb/database/database.go
@@ -17,7 +17,7 @@
package database
import (
- "github.com/ethereum/go-ethereum/common"
+ "github.com/tenderly/op-geth/common"
)
// Reader wraps the Node method of a backing trie reader.
diff --git go-ethereum/triedb/hashdb/database.go op-geth/triedb/hashdb/database.go
index e45ccdba32ca099ef570c2544a41f80245d25191..cf03bca1ab2d1e7282cf9956440b00e9ac73b28c 100644
--- go-ethereum/triedb/hashdb/database.go
+++ op-geth/triedb/hashdb/database.go
@@ -24,15 +24,15 @@ "sync"
"time"
"github.com/VictoriaMetrics/fastcache"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/metrics"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/triestate"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/metrics"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/triestate"
)
var (
diff --git go-ethereum/triedb/pathdb/database.go op-geth/triedb/pathdb/database.go
index f2d6cea635a9b7a37308b15022eef2fd99a3e24c..40dd32d72ec5e3f55a98eb01ea162e82124c5ba4 100644
--- go-ethereum/triedb/pathdb/database.go
+++ op-geth/triedb/pathdb/database.go
@@ -23,14 +23,14 @@ "io"
"sync"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/triestate"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/params"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/triestate"
)
const (
diff --git go-ethereum/triedb/pathdb/difflayer.go op-geth/triedb/pathdb/difflayer.go
index 10567715d2e71e98052ed8d755e1aedf0356d234..c659313d81eb5cd2007857d68d19348f5d7a8e7f 100644
--- go-ethereum/triedb/pathdb/difflayer.go
+++ op-geth/triedb/pathdb/difflayer.go
@@ -20,10 +20,10 @@ import (
"fmt"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/triestate"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/triestate"
)
// diffLayer represents a collection of modifications made to the in-memory tries
diff --git go-ethereum/triedb/pathdb/disklayer.go op-geth/triedb/pathdb/disklayer.go
index ef697cbce8ce65dcc5aeb2657a1565c8a2be2026..2ffd96192035eae018d5815bf85bfacf2e3ee458 100644
--- go-ethereum/triedb/pathdb/disklayer.go
+++ op-geth/triedb/pathdb/disklayer.go
@@ -22,12 +22,12 @@ "fmt"
"sync"
"github.com/VictoriaMetrics/fastcache"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/triestate"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/triestate"
"golang.org/x/crypto/sha3"
)
diff --git go-ethereum/triedb/pathdb/errors.go op-geth/triedb/pathdb/errors.go
index 78ee4459fe50943d103ca2400173c6786317dfd0..7107d44eecc3f10a3ac89da08e893404d90e1384 100644
--- go-ethereum/triedb/pathdb/errors.go
+++ op-geth/triedb/pathdb/errors.go
@@ -20,8 +20,8 @@ import (
"errors"
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/common/hexutil"
)
var (
diff --git go-ethereum/triedb/pathdb/history.go op-geth/triedb/pathdb/history.go
index 6e3f3faaedce939ea7b944b9f0e394aece5d40fa..844b9eae56b6501a7156783746c3b54cc739dc77 100644
--- go-ethereum/triedb/pathdb/history.go
+++ op-geth/triedb/pathdb/history.go
@@ -23,11 +23,11 @@ "errors"
"fmt"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/trie/triestate"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/trie/triestate"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/triedb/pathdb/journal.go op-geth/triedb/pathdb/journal.go
index ac770763e38df7315728ad1734720b8070776ec9..7f64826a660642eaba3145e4f0cc5e0c8696ef84 100644
--- go-ethereum/triedb/pathdb/journal.go
+++ op-geth/triedb/pathdb/journal.go
@@ -23,14 +23,14 @@ "fmt"
"io"
"time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/triestate"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/rlp"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/triestate"
)
var (
diff --git go-ethereum/triedb/pathdb/layertree.go op-geth/triedb/pathdb/layertree.go
index d314779910e9ac716a71e27cb96493951a00454f..6d3c57a236bddbc5e4ff239b7d8f2ce0b613ac3f 100644
--- go-ethereum/triedb/pathdb/layertree.go
+++ op-geth/triedb/pathdb/layertree.go
@@ -21,10 +21,10 @@ "errors"
"fmt"
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/triestate"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/triestate"
)
// layerTree is a group of state layers identified by the state root.
diff --git go-ethereum/triedb/pathdb/metrics.go op-geth/triedb/pathdb/metrics.go
index 9e2b1dcbf55e576faaf223b68fd358e86d8fbfba..c505a12edd037892bfebe3fc1dd5d9a1b2cac45e 100644
--- go-ethereum/triedb/pathdb/metrics.go
+++ op-geth/triedb/pathdb/metrics.go
@@ -16,7 +16,7 @@ // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>
package pathdb
-import "github.com/ethereum/go-ethereum/metrics"
+import "github.com/tenderly/op-geth/metrics"
var (
cleanHitMeter = metrics.NewRegisteredMeter("pathdb/clean/hit", nil)
diff --git go-ethereum/triedb/pathdb/nodebuffer.go op-geth/triedb/pathdb/nodebuffer.go
index 4a7d328b9afb8fbbad679028debbaf3a07146581..6027bd705005a521150d9fb1b5c198e042604cd1 100644
--- go-ethereum/triedb/pathdb/nodebuffer.go
+++ op-geth/triedb/pathdb/nodebuffer.go
@@ -21,12 +21,12 @@ "fmt"
"time"
"github.com/VictoriaMetrics/fastcache"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/trie/trienode"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/ethdb"
+ "github.com/tenderly/op-geth/log"
+ "github.com/tenderly/op-geth/trie/trienode"
)
// nodebuffer is a collection of modified trie nodes to aggregate the disk
diff --git go-ethereum/triedb/pathdb/testutils.go op-geth/triedb/pathdb/testutils.go
index d6fdacb4213e376492b7564e627e964c2f97214f..e4a325209d966cd4886d0c8512749abd536a9bc7 100644
--- go-ethereum/triedb/pathdb/testutils.go
+++ op-geth/triedb/pathdb/testutils.go
@@ -20,11 +20,11 @@ import (
"bytes"
"fmt"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/trie/trienode"
- "github.com/ethereum/go-ethereum/trie/triestate"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/types"
+ "github.com/tenderly/op-geth/crypto"
+ "github.com/tenderly/op-geth/trie/trienode"
+ "github.com/tenderly/op-geth/trie/triestate"
"golang.org/x/exp/slices"
)
diff --git go-ethereum/triedb/preimages.go op-geth/triedb/preimages.go
index a5384910f755d5af37a4fcd6dadedc5af37b3f2f..6d101396981d1055c22a885deae148f46216a7b7 100644
--- go-ethereum/triedb/preimages.go
+++ op-geth/triedb/preimages.go
@@ -19,9 +19,9 @@
import (
"sync"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/tenderly/op-geth/common"
+ "github.com/tenderly/op-geth/core/rawdb"
+ "github.com/tenderly/op-geth/ethdb"
)
// preimageStore is the store for caching preimages of node key.
Ignored changes
+6234
-60
diff --git go-ethereum/.circleci/check-releases.sh op-geth/.circleci/check-releases.sh
new file mode 100755
index 0000000000000000000000000000000000000000..208514185906aeebcbde771f9de7fb6a0c1c11df
--- /dev/null
+++ op-geth/.circleci/check-releases.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+set -euo pipefail
+
+LATEST_RELEASE=$(curl -s --fail -L \
+ -H "Accept: application/vnd.github+json" \
+ -H "X-GitHub-Api-Version: 2022-11-28" \
+ https://api.github.com/repos/ethereum/go-ethereum/releases \
+ | jq -r '(.[] | select(.draft==false) | select(.prerelease==false)).tag_name' | head -n 1)
+
+echo "Detected latest go-ethereum release as ${LATEST_RELEASE}"
+
+git remote add upstream https://github.com/tenderly/op-geth
+git fetch upstream > /dev/null
+
+if git branch --contains "${LATEST_RELEASE}" 2>&1 | grep -e '^[ *]*optimism$' > /dev/null
+then
+ echo "Up to date with latest release. Great job! 🎉"
+else
+ echo "Release has not been merged"
+ exit 1
+fi
diff --git go-ethereum/.circleci/ci-docker-tag-op-geth-release.sh op-geth/.circleci/ci-docker-tag-op-geth-release.sh
new file mode 100755
index 0000000000000000000000000000000000000000..7b66e789a4d7e50699f2d22ff037117c0d7a3a35
--- /dev/null
+++ op-geth/.circleci/ci-docker-tag-op-geth-release.sh
@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+DOCKER_REPO=$1
+GIT_TAG=$2
+GIT_SHA=$3
+
+IMAGE_NAME="op-geth"
+IMAGE_TAG=$GIT_TAG
+
+SOURCE_IMAGE_TAG="$DOCKER_REPO/$IMAGE_NAME:$GIT_SHA"
+TARGET_IMAGE_TAG="$DOCKER_REPO/$IMAGE_NAME:$IMAGE_TAG"
+TARGET_IMAGE_TAG_LATEST="$DOCKER_REPO/$IMAGE_NAME:latest"
+
+echo "Checking if docker images exist for '$IMAGE_NAME'"
+echo ""
+tags=$(gcloud container images list-tags "$DOCKER_REPO/$IMAGE_NAME" --limit 1 --format json)
+if [ "$tags" = "[]" ]; then
+ echo "No existing docker images were found for '$IMAGE_NAME'. The code tagged with '$GIT_TAG' may not have an associated dockerfile or docker build job."
+ echo "If this service has a dockerfile, add a docker-publish job for it in the circleci config."
+ echo ""
+ echo "Exiting"
+ exit 0
+fi
+
+echo "Tagging $SOURCE_IMAGE_TAG with '$IMAGE_TAG'"
+gcloud container images add-tag -q "$SOURCE_IMAGE_TAG" "$TARGET_IMAGE_TAG"
+
+# Do not tag with latest if the release is a release candidate.
+if [[ "$IMAGE_TAG" == *"rc"* ]]; then
+ echo "Not tagging with 'latest' because the release is a release candidate."
+ exit 0
+fi
+
+echo "Tagging $SOURCE_IMAGE_TAG with 'latest'"
+gcloud container images add-tag -q "$SOURCE_IMAGE_TAG" "$TARGET_IMAGE_TAG_LATEST"
+
diff --git go-ethereum/.circleci/config.yml op-geth/.circleci/config.yml
new file mode 100644
index 0000000000000000000000000000000000000000..ad9793ad9873c294d4c128d575406fc0710ee20c
--- /dev/null
+++ op-geth/.circleci/config.yml
@@ -0,0 +1,230 @@
+version: 2.1
+
+orbs:
+ gcp-cli: circleci/gcp-cli@3.0.1
+ slack: circleci/slack@4.10.1
+
+commands:
+ gcp-oidc-authenticate:
+ description: "Authenticate with GCP using a CircleCI OIDC token."
+ parameters:
+ project_id:
+ type: env_var_name
+ default: GCP_PROJECT_ID
+ workload_identity_pool_id:
+ type: env_var_name
+ default: GCP_WIP_ID
+ workload_identity_pool_provider_id:
+ type: env_var_name
+ default: GCP_WIP_PROVIDER_ID
+ service_account_email:
+ type: env_var_name
+ default: GCP_SERVICE_ACCOUNT_EMAIL
+ gcp_cred_config_file_path:
+ type: string
+ default: /home/circleci/gcp_cred_config.json
+ oidc_token_file_path:
+ type: string
+ default: /home/circleci/oidc_token.json
+ steps:
+ - run:
+ name: "Create OIDC credential configuration"
+ command: |
+ # Store OIDC token in temp file
+ echo $CIRCLE_OIDC_TOKEN > << parameters.oidc_token_file_path >>
+ # Create a credential configuration for the generated OIDC ID Token
+ gcloud iam workload-identity-pools create-cred-config \
+ "projects/${<< parameters.project_id >>}/locations/global/workloadIdentityPools/${<< parameters.workload_identity_pool_id >>}/providers/${<< parameters.workload_identity_pool_provider_id >>}"\
+ --output-file="<< parameters.gcp_cred_config_file_path >>" \
+ --service-account="${<< parameters.service_account_email >>}" \
+ --credential-source-file=<< parameters.oidc_token_file_path >>
+ - run:
+ name: "Authenticate with GCP using OIDC"
+ command: |
+ # Configure gcloud to leverage the generated credential configuration
+ gcloud auth login --brief --cred-file "<< parameters.gcp_cred_config_file_path >>"
+ # Configure ADC
+ echo "export GOOGLE_APPLICATION_CREDENTIALS='<< parameters.gcp_cred_config_file_path >>'" | tee -a "$BASH_ENV"
+
+jobs:
+ docker-release:
+ environment:
+ DOCKER_BUILDKIT: 1
+ parameters:
+ docker_name:
+ description: Docker image name
+ type: string
+ default: "op-geth"
+ docker_tags:
+ description: Docker image tags as csv
+ type: string
+ registry:
+ description: Docker registry
+ type: string
+ default: "us-docker.pkg.dev"
+ repo:
+ description: Docker repo
+ type: string
+ default: "oplabs-tools-artifacts/images"
+ push_tags:
+ description: Push release push tags
+ type: boolean
+ default: false
+ machine:
+ image: default
+ resource_class: xlarge
+ steps:
+ - gcp-cli/install
+ - gcp-oidc-authenticate
+ - checkout
+ - run:
+ name: Configure Docker
+ command: |
+ gcloud auth configure-docker <<parameters.registry>>
+ - run:
+ name: Build and push
+ command: |
+ RAW_TAGS="<<parameters.docker_tags>>"
+ if [ "$CIRCLE_BRANCH" = "optimism" ]; then
+ RAW_TAGS="$RAW_TAGS,optimism"
+ fi
+ IMAGE_BASE="<<parameters.registry>>/<<parameters.repo>>/<<parameters.docker_name>>"
+ DOCKER_TAGS=$(echo -ne "$RAW_TAGS" | sed "s/,/\n/g" | sed "s/[^a-zA-Z0-9\n.]/-/g" | sed -e "s|^|-t ${IMAGE_BASE}:|")
+ docker context create buildx-build
+ docker buildx create --use buildx-build
+ docker buildx build --push \
+ $(echo -ne $DOCKER_TAGS | tr '\n' ' ') \
+ --platform=linux/arm64,linux/amd64 \
+ --build-arg VERSION=$CIRCLE_TAG \
+ --build-arg COMMIT=$CIRCLE_SHA \
+ --build-arg BUILDNUM=$CIRCLE_BUILD_NUM \
+ --progress plain \
+ -f Dockerfile .
+ - when:
+ condition:
+ equal: [ true, <<parameters.push_tags>> ]
+ steps:
+ - run:
+ name: Tag
+ command: |
+ ./.circleci/ci-docker-tag-op-geth-release.sh <<parameters.registry>>/<<parameters.repo>> $CIRCLE_TAG $CIRCLE_SHA1
+ - when:
+ condition:
+ equal: [optimism, << pipeline.git.branch >>]
+ steps:
+ - gcp-oidc-authenticate:
+ service_account_email: GCP_SERVICE_ATTESTOR_ACCOUNT_EMAIL
+ - run:
+ name: Sign
+ command: |
+ git clone --branch v1.0.3 --depth 1 https://github.com/ethereum-optimism/binary_signer
+ cd binary_signer/signer
+
+ IMAGE_PATH="<<parameters.registry>>/<<parameters.repo>>/<<parameters.docker_name>>:<<pipeline.git.revision>>"
+ echo $IMAGE_PATH
+ pip3 install -r requirements.txt
+
+ python3 ./sign_image.py --command="sign"\
+ --attestor-project-name="$ATTESTOR_PROJECT_NAME"\
+ --attestor-name="$ATTESTOR_NAME"\
+ --image-path="$IMAGE_PATH"\
+ --signer-logging-level="INFO"\
+ --attestor-key-id="//cloudkms.googleapis.com/v1/projects/$ATTESTOR_PROJECT_NAME/locations/global/keyRings/$ATTESTOR_NAME-key-ring/cryptoKeys/$ATTESTOR_NAME-key/cryptoKeyVersions/1"
+
+
+ build-geth:
+ docker:
+ - image: cimg/go:1.21
+ resource_class: xlarge
+ steps:
+ - checkout
+ - run:
+ command: go run build/ci.go install
+ unit-test:
+ resource_class: xlarge
+ docker:
+ - image: cimg/go:1.21
+ steps:
+ - checkout
+ - run:
+ command: go run build/ci.go test
+ lint-geth:
+ resource_class: medium
+ docker:
+ - image: cimg/go:1.21
+ steps:
+ - checkout
+ - run:
+ command: go run build/ci.go lint
+ tidy-geth:
+ resource_class: small
+ docker:
+ - image: cimg/go:1.21
+ steps:
+ - checkout
+ - run:
+ command: go mod tidy && git diff --exit-code
+ check-releases:
+ docker:
+ - image: cimg/go:1.21
+ steps:
+ - checkout
+ - run:
+ command: .circleci/check-releases.sh
+ - slack/notify:
+ channel: C03N11M0BBN
+ branch_pattern: optimism
+ event: fail
+ template: basic_fail_1
+
+
+workflows:
+ main:
+ jobs:
+ - build-geth:
+ name: Build geth
+ - unit-test:
+ name: Run unit tests for geth
+ - lint-geth:
+ name: Run linter over geth
+ - tidy-geth:
+ name: Check geth go.mod file has been tidied
+ - docker-release:
+ name: Push to Docker
+ docker_tags: <<pipeline.git.revision>>
+ context:
+ - oplabs-gcr
+ release:
+ jobs:
+ - hold:
+ type: approval
+ filters:
+ tags:
+ only: /^v.*/
+ branches:
+ ignore: /.*/
+ - docker-release:
+ name: Push to Docker (release)
+ filters:
+ tags:
+ only: /^v.*/
+ branches:
+ ignore: /.*/
+ docker_tags: <<pipeline.git.revision>>,<<pipeline.git.tag>>
+ push_tags: true
+ context:
+ - oplabs-gcr-release
+ requires:
+ - hold
+ scheduled:
+ triggers:
+ - schedule:
+ # run daily
+ cron: "0 0 * * *"
+ filters:
+ branches:
+ only: [ "optimism" ]
+ jobs:
+ - check-releases:
+ name: Check for new upstream releases
+ context: slack
diff --git go-ethereum/.github/CODEOWNERS op-geth/.github/CODEOWNERS
index faf922df01613ecabaee93c1153b91476573e914..a52ce4b85b205e9378cd398ffd103616baabda0a 100644
--- go-ethereum/.github/CODEOWNERS
+++ op-geth/.github/CODEOWNERS
@@ -1,22 +1 @@
-# Lines starting with '#' are comments.
-# Each line is a file pattern followed by one or more owners.
-
-accounts/usbwallet @karalabe
-accounts/scwallet @gballet
-accounts/abi @gballet @MariusVanDerWijden
-cmd/clef @holiman
-consensus @karalabe
-core/ @karalabe @holiman @rjl493456442
-eth/ @karalabe @holiman @rjl493456442
-eth/catalyst/ @gballet
-eth/tracers/ @s1na
-graphql/ @s1na
-les/ @zsfelfoldi @rjl493456442
-light/ @zsfelfoldi @rjl493456442
-node/ @fjl
-p2p/ @fjl @zsfelfoldi
-rpc/ @fjl @holiman
-p2p/simulations @fjl
-p2p/protocols @fjl
-p2p/testing @fjl
-signer/ @holiman
+* @ethereum-optimism/op-geth-maintainers
\ No newline at end of file
diff --git go-ethereum/.github/workflows/go.yml op-geth/.github/workflows/go.yml
deleted file mode 100644
index 0c673d15f16851ad2a633860fc4cec8a0346aee5..0000000000000000000000000000000000000000
--- go-ethereum/.github/workflows/go.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: i386 linux tests
-
-on:
- push:
- branches: [ master ]
- pull_request:
- branches: [ master ]
- workflow_dispatch:
-
-jobs:
- build:
- runs-on: self-hosted
- steps:
- - uses: actions/checkout@v2
- - name: Set up Go
- uses: actions/setup-go@v2
- with:
- go-version: 1.21.4
- - name: Run tests
- run: go test -short ./...
- env:
- GOOS: linux
- GOARCH: 386
diff --git go-ethereum/.github/workflows/pages.yaml op-geth/.github/workflows/pages.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3c45b5d3390e8fa379824c7001f308ad721a2f86
--- /dev/null
+++ op-geth/.github/workflows/pages.yaml
@@ -0,0 +1,36 @@
+name: Build and publish forkdiff github-pages
+permissions:
+ contents: write
+on:
+ push:
+ branches:
+ - optimism
+jobs:
+ deploy:
+ concurrency: ci-${{ github.ref }}
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v3
+ with:
+ fetch-depth: 1000 # make sure to fetch the old commit we diff against
+
+ - name: Build forkdiff
+ uses: "docker://protolambda/forkdiff:0.1.0"
+ with:
+ args: -repo=/github/workspace -fork=/github/workspace/fork.yaml -out=/github/workspace/index.html
+
+ - name: Build pages
+ run: |
+ mkdir -p tmp/pages
+ mv index.html tmp/pages/index.html
+ touch tmp/pages/.nojekyll
+ if [ "$GITHUB_REPOSITORY" == "ethereum-optimism/op-geth" ]; then
+ echo "op-geth.optimism.io" > tmp/pages/CNAME
+ fi;
+
+ - name: Deploy
+ uses: JamesIves/github-pages-deploy-action@v4
+ with:
+ folder: tmp/pages
+ clean: true
diff --git go-ethereum/.golangci.yml op-geth/.golangci.yml
index 0343c4b4ebf2eec8adc0a473a2892a4100b3a86a..ca2f7f2a38a8f7e97e6546041c117cef3bbdfb71 100644
--- go-ethereum/.golangci.yml
+++ op-geth/.golangci.yml
@@ -1,13 +1,12 @@
# This file configures github.com/golangci/golangci-lint.
+# see <https://golangci-lint.run/usage/configuration>
run:
timeout: 20m
tests: true
# default is true. Enables skipping of directories:
# vendor$, third_party$, testdata$, examples$, Godeps$, builtin$
- skip-dirs-use-default: true
- skip-files:
- - core/genesis_alloc.go
+
linters:
disable-all: true
@@ -40,6 +39,9 @@ gofmt:
simplify: true
issues:
+ exclude-dirs-use-default: true
+ exclude-dirs:
+ - core/genesis_alloc.go
exclude-rules:
- path: crypto/bn256/cloudflare/optate.go
linters:
@@ -58,3 +60,4 @@ - 'SA1019: event.TypeMux is deprecated: use Feed'
- 'SA1019: strings.Title is deprecated'
- 'SA1019: strings.Title has been deprecated since Go 1.18 and an alternative has been available since Go 1.0: The rule Title uses for word boundaries does not handle Unicode punctuation properly. Use golang.org/x/text/cases instead.'
- 'SA1029: should not use built-in type string as key for value'
+ - 'SA1019:' # temporary, until fully updated to Go 1.21
diff --git go-ethereum/Makefile op-geth/Makefile
index 99b8ba54b4929d34c7fe4e8dba7268f3339a6778..b82300690419b52af2764c948615565169ada790 100644
--- go-ethereum/Makefile
+++ op-geth/Makefile
@@ -43,6 +43,12 @@ env GOBIN= go install ./cmd/abigen
@type "solc" 2> /dev/null || echo 'Please install solc'
@type "protoc" 2> /dev/null || echo 'Please install protoc'
+forkdiff:
+ docker run --rm \
+ --mount src=$(shell pwd),target=/host-pwd,type=bind \
+ protolambda/forkdiff:latest \
+ -repo /host-pwd/ -fork /host-pwd/fork.yaml -out /host-pwd/forkdiff.html
+
#? help: Get more info on make commands.
help: Makefile
@echo " Choose a command run in go-ethereum:"
diff --git go-ethereum/core/vm/testdata/precompiles/p256Verify.json op-geth/core/vm/testdata/precompiles/p256Verify.json
new file mode 100644
index 0000000000000000000000000000000000000000..b631d907ac523bd8ca8e3712314a0047f4cf4115
--- /dev/null
+++ op-geth/core/vm/testdata/precompiles/p256Verify.json
@@ -0,0 +1,5469 @@
+[
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e184cd60b855d442f5b3c7b11eb6c4e0ae7525fe710fab9aa7c77a67f79e6fadd762927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #1: signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023d45c5740946b2a147f59262ee6f5bc90bd01ed280528b62b3aed5fc93f06f739b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #3: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023d45c5741946b2a137f59262ee6f5bc91001af27a5e1117a64733950642a3d1e8b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #5: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e184cd60b865d442f5a3c7b11eb6c4e0ae79578ec6353a20bf783ecb4b6ea97b8252927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #8: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #9: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #10: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #11: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #12: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #13: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000000ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #14: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000000ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #15: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #16: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #17: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000001ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #18: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000001ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #19: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000001ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #20: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000001ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #21: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000001ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #22: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255100000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #23: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255100000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #24: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #25: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #26: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #27: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #28: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #29: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255000000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #30: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255000000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #31: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #32: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #33: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #34: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #35: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #36: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255200000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #37: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255200000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #38: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #39: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #40: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #41: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #42: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #43: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #44: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #45: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #46: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #47: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #48: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #49: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #50: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff0000000100000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #51: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff0000000100000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #52: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #53: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #54: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #55: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #56: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #57: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "70239dd877f7c944c422f44dea4ed1a52f2627416faf2f072fa50c772ed6f80764a1aab5000d0e804f3e2fc02bdee9be8ff312334e2ba16d11547c97711c898e6af015971cc30be6d1a206d4e013e0997772a2f91d73286ffd683b9bb2cf4f1b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #58: Edge case for Shamir multiplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "00000000690ed426ccf17803ebe2bd0884bcd58a1bb5e7477ead3645f356e7a916aea964a2f6506d6f78c81c91fc7e8bded7d397738448de1e19a0ec580bf266252cd762130c6667cfe8b7bc47d27d78391e8e80c578d1cd38c3ff033be928e92927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #59: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7300000000213f2a525c6035725235c2f696ad3ebb5ee47f140697ad25770d919cc98be2347d469bf476dfc26b9b733df2d26d6ef524af917c665baccb23c882093496459effe2d8d70727b82462f61d0ec1b7847929d10ea631dacb16b56c322927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #60: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ddf2000000005e0be0635b245f0b97978afd25daadeb3edb4a0161c27fe0604573b3c90ecd390028058164524dde892703dce3dea0d53fa8093999f07ab8aa432f67b0b8e20636695bb7d8bf0a651c802ed25a395387b5f4188c0c4075c886342927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #61: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "67ab1900000000784769c4ecb9e164d6642b8499588b89855be1ec355d0841a0bfab3098252847b328fadf2f89b95c851a7f0eb390763378f37e90119d5ba3ddbdd64e234e832b1067c2d058ccb44d978195ccebb65c2aaf1e2da9b8b4987e3b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #62: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a2bf09460000000076d7dbeffe125eaf02095dff252ee905e296b6350fc311cf204a9784074b246d8bf8bf04a4ceb1c1f1c9aaab168b1596d17093c5cd21d2cd51cce41670636783dc06a759c8847868a406c2506fe17975582fe648d1d88b522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #63: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3554e827c700000000e1e75e624a06b3a0a353171160858129e15c544e4f0e65ed66dc34f551ac82f63d4aa4f81fe2cb0031a91d1314f835027bca0f1ceeaa0399ca123aa09b13cd194a422e18d5fda167623c3f6e5d4d6abb8953d67c0c48c72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #64: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9b6cd3b812610000000026941a0f0bb53255ea4c9fd0cb3426e3a54b9fc6965c060b700bef665c68899d44f2356a578d126b062023ccc3c056bf0f60a237012b8d186c027832965f4fcc78a3366ca95dedbb410cbef3f26d6be5d581c11d36102927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #65: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "883ae39f50bf0100000000e7561c26fc82a52baa51c71ca877162f93c4ae01869f6adfe8d5eb5b2c24d7aa7934b6cf29c93ea76cd313c9132bb0c8e38c96831db26a9c9e40e55ee0890c944cf271756c906a33e66b5bd15e051593883b5e99022927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #66: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a1ce5d6e5ecaf28b0000000000fa7cd010540f420fb4ff7401fe9fce011d0ba6a1af03ca91677b673ad2f33615e56174a1abf6da168cebfa8868f4ba273f16b720aa73ffe48afa6435cd258b173d0c2377d69022e7d098d75caf24c8c5e06b1c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #67: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8ea5f645f373f580930000000038345397330012a8ee836c5494cdffd5ee8054fdc70602766f8eed11a6c99a71c973d5659355507b843da6e327a28c11893db93df5349688a085b137b1eacf456a9e9e0f6d15ec0078ca60a7f83f2b10d213502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #68: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "660570d323e9f75fa734000000008792d65ce93eabb7d60d8d9c1bbdcb5ef305b516a314f2fce530d6537f6a6c49966c23456f63c643cf8e0dc738f7b876e675d39ffd033c92b6d717dd536fbc5efdf1967c4bd80954479ba66b0120cd16fff22927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #69: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d0462673154cce587dde8800000000e98d35f1f45cf9c3bf46ada2de4c568c343b2cbf046eac45842ecb7984d475831582717bebb6492fd0a485c101e29ff0a84c9b7b47a98b0f82de512bc9313aaf51701099cac5f76e68c8595fc1c1d992582927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #70: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bd90640269a7822680cedfef000000000caef15a6171059ab83e7b4418d7278f30c87d35e636f540841f14af54e2f9edd79d0312cfa1ab656c3fb15bfde48dcf47c15a5a82d24b75c85a692bd6ecafeb71409ede23efd08e0db9abf6340677ed2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #71: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "33239a52d72f1311512e41222a00000000d2dcceb301c54b4beae8e284788a7338686ff0fda2cef6bc43b58cfe6647b9e2e8176d168dec3c68ff262113760f52067ec3b651f422669601662167fa8717e976e2db5e6a4cf7c2ddabb3fde9d67d2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #72: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "b8d64fbcd4a1c10f1365d4e6d95c000000007ee4a21a1cbe1dc84c2d941ffaf144a3e23bf314f2b344fc25c7f2de8b6af3e17d27f5ee844b225985ab6e2775cf2d48e223205e98041ddc87be532abed584f0411f5729500493c9cc3f4dd15e862927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #73: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "01603d3982bf77d7a3fef3183ed092000000003a227420db4088b20fe0e9d84a2ded5b7ec8e90e7bf11f967a3d95110c41b99db3b5aa8d330eb9d638781688e97d5792c53628155e1bfc46fb1a67e3088de049c328ae1f44ec69238a009808f92927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #74: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9ea6994f1e0384c8599aa02e6cf66d9c000000004d89ef50b7e9eb0cfbff7363bdae7bcb580bf335efd3bc3d31870f923eaccafcd40ec2f605976f15137d8b8ff6dfa12f19e525270b0106eecfe257499f373a4fb318994f24838122ce7ec3c72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #75: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d03215a8401bcf16693979371a01068a4700000000e2fa5bf692bc670905b18c50f9c4f0cd6940e162720957ffff513799209b78596956d21ece251c2401f1c6d7033a0a787d338e889defaaabb106b95a4355e411a59c32aa5167dfab2447262927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #76: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "307bfaaffb650c889c84bf83f0300e5dc87e000000008408fd5f64b582e3bb14f612820687604fa01906066a378d67540982e29575d019aabe90924ead5c860d3f9367702dd7dd4f75ea98afd20e328a1a99f4857b316525328230ce294b0fef2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #77: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bab5c4f4df540d7b33324d36bb0c157551527c00000000e4af574bb4d54ea6b89505e407657d6e8bc93db5da7aa6f5081f61980c1949f56b0f2f507da5782a7ac60d31904e3669738ffbeccab6c3656c08e0ed5cb92b3cfa5e7f71784f9c50212927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #78: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d4ba47f6ae28f274e4f58d8036f9c36ec2456f5b00000000c3b869197ef5e15ebbd16fbbb656b6d0d83e6a7787cd691b08735aed371732723e1c68a40404517d9d8e35dba96028b7787d91315be675877d2d097be5e8ee34560e3e7fd25c0f002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #79: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "79fd19c7235ea212f29f1fa00984342afe0f10aafd00000000801e47f8c184e12ec9760122db98fd06ea76848d35a6da442d2ceef7559a30cf57c61e92df327e7ab271da90859479701fccf86e462ee3393fb6814c27b760c4963625c0a198782927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #80: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8c291e8eeaa45adbaf9aba5c0583462d79cbeb7ac97300000000a37ea6700cda54e76b7683b6650baa6a7fc49b1c51eed9ba9dd463221f7a4f1005a89fe00c592ea076886c773eb937ec1cc8374b7915cfd11b1c1ae1166152f2f7806a31c8fd2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #81: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0eaae8641084fa979803efbfb8140732f4cdcf66c3f78a000000003c278a6b215291deaf24659ffbbce6e3c26f6021097a74abdbb69be4fb10419c0c496c946665d6fcf336d27cc7cdb982bb4e4ecef5827f84742f29f10abf83469270a03dc32927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #82: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "e02716d01fb23a5a0068399bf01bab42ef17c6d96e13846c00000000afc0f89d207a3241812d75d947419dc58efb05e8003b33fc17eb50f9d15166a88479f107cdee749f2e492b213ce80b32d0574f62f1c5d70793cf55e382d5caadf75927672927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #83: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9eb0bf583a1a6b9a194e9a16bc7dab2a9061768af89d00659a00000000fc7de16554e49f82a855204328ac94913bf01bbe84437a355a0a37c0dee3cf81aa7728aea00de2507ddaf5c94e1e126980d3df16250a2eaebc8be486effe7f22b4f9292927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #84: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "62aac98818b3b84a2c214f0d5e72ef286e1030cb53d9a82b690e00000000cd15a54c5062648339d2bff06f71c88216c26c6e19b4d80a8c602990ac82707efdfce99bbe7fcfafae3e69fd016777517aa01056317f467ad09aff09be73c9731b0d2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #85: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3760a7f37cf96218f29ae43732e513efd2b6f552ea4b6895464b9300000000c8975bd7157a8d363b309f1f444012b1a1d23096593133e71b4ca8b059cff37eaf7faa7a28b1c822baa241793f2abc930bd4c69840fe090f2aacc46786bf9196222927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #86: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0da0a1d2851d33023834f2098c0880096b4320bea836cd9cbb6ff6c8000000005694a6f84b8f875c276afd2ebcfe4d61de9ec90305afb1357b95b3e0da43885e0dffad9ffd0b757d8051dec02ebdf70d8ee2dc5c7870c0823b6ccc7c679cbaa42927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #87: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ffffffff293886d3086fd567aafd598f0fe975f735887194a764a231e82d289aa0c30e8026fdb2b4b4968a27d16a6d08f7098f1a98d21620d7454ba9790f1ba65e470453a8a399f15baf463f9deceb53acc5ca64459149688bd2760c654243392927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #88: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7bffffffff2376d1e3c03445a072e24326acdc4ce127ec2e0e8d9ca99527e7b7614ea84acf736527dd73602cd4bb4eea1dfebebd5ad8aca52aa0228cf7b99a88737cc85f5f2d2f60d1b8183f3ed490e4de14368e96a9482c2a4dd193195c902f2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #89: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a2b5ffffffffebb251b085377605a224bc80872602a6e467fd016807e97fa395bead6734ebe44b810d3fb2ea00b1732945377338febfd439a8d74dfbd0f942fa6bb18eae36616a7d3cad35919fd21a8af4bbe7a10f73b3e036a46b103ef56e2a2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #90: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "641227ffffffff6f1b96fa5f097fcf3cc1a3c256870d45a67b83d0967d4b20c0499625479e161dacd4db9d9ce64854c98d922cbf212703e9654fae182df9bad242c177cf37b8193a0131108d97819edd9439936028864ac195b64fca76d9d6932927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #91: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "958415d8ffffffffabad03e2fc662dc3ba203521177502298df56f36600e0f8b08f16b8093a8fb4d66a2c8065b541b3d31e3bfe694f6b89c50fb1aaa6ff6c9b29d6455e2d5d1779748573b611cb95d4a21f967410399b39b535ba3e5af81ca2e2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #92: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "f1d8de4858ffffffff1281093536f47fe13deb04e1fbe8fb954521b6975420f8be26231b6191658a19dd72ddb99ed8f8c579b6938d19bce8eed8dc2b338cb5f8e1d9a32ee56cffed37f0f22b2dcb57d5c943c14f79694a03b9c5e96952575c892927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #93: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0927895f2802ffffffff10782dd14a3b32dc5d47c05ef6f1876b95c81fc31def15e76880898316b16204ac920a02d58045f36a229d4aa4f812638c455abe0443e74d357d3fcb5c8c5337bd6aba4178b455ca10e226e13f9638196506a19391232927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #94: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "60907984aa7e8effffffff4f332862a10a57c3063fb5a30624cf6a0c3ac80589352ecb53f8df2c503a45f9846fc28d1d31e6307d3ddbffc1132315cc07f16dad1348dfa9c482c558e1d05c5242ca1c39436726ecd28258b1899792887dd0a3c62927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #95: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "c6ff198484939170ffffffff0af42cda50f9a5f50636ea6942d6b9b8cd6ae1e24a40801a7e606ba78a0da9882ab23c7677b8642349ed3d652c5bfa5f2a9558fb3a49b64848d682ef7f605f2832f7384bdc24ed2925825bf8ea77dc59817257822927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #96: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de030419345ca15c75ffffffff8074799b9e0956cc43135d16dfbe4d27d7e68deacc5e1a8304a74d2be412b078924b3bb3511bac855c05c9e5e9e44df3d61e967451cd8e18d6ed1885dd827714847f96ec4bb0ed4c36ce9808db8f714204f6d12927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #97: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "6f0e3eeaf42b28132b88fffffffff6c8665604d34acb19037e1ab78caaaac6ff2f7a5e9e5771d424f30f67fdab61e8ce4f8cd1214882adb65f7de94c31577052ac4e69808345809b44acb0b2bd889175fb75dd050c5a449ab9528f8f78daa10c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #98: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "cdb549f773b3e62b3708d1ffffffffbe48f7c0591ddcae7d2cb222d1f8017ab9ffcda40f792ce4d93e7e0f0e95e1a2147dddd7f6487621c30a03d710b330021979938b55f8a17f7ed7ba9ade8f2065a1fa77618f0b67add8d58c422c2453a49a2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #99: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2c3f26f96a3ac0051df4989bffffffff9fd64886c1dc4f9924d8fd6f0edb048481f2359c4faba6b53d3e8c8c3fcc16a948350f7ab3a588b28c17603a431e39a8cd6f6a5cc3b55ead0ff695d06c6860b509e46d99fccefb9f7f9e101857f743002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #100: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ac18f8418c55a2502cb7d53f9affffffff5c31d89fda6a6b8476397c04edf411dfc8bf520445cbb8ee1596fb073ea283ea130251a6fdffa5c3f5f2aaf75ca808048e33efce147c9dd92823640e338e68bfd7d0dc7a4905b3a7ac711e577e90e72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #101: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "4f9618f98e2d3a15b24094f72bb5ffffffffa2fd3e2893683e5a6ab8cf0ee610ad019f74c6941d20efda70b46c53db166503a0e393e932f688227688ba6a576293320eb7ca0710255346bdbb3102cdcf7964ef2e0988e712bc05efe16c1993452927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #102: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "422e82a3d56ed10a9cc21d31d37a25ffffffff67edf7c40204caae73ab0bc75aac8096842e8add68c34e78ce11dd71e4b54316bd3ebf7fffdeb7bd5a3ebc1883f5ca2f4f23d674502d4caf85d187215d36e3ce9f0ce219709f21a3aac003b7a82927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #103: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7075d245ccc3281b6e7b329ff738fbb417a5ffffffffa0842d9890b5cf95d018677b2d3a59b18a5ff939b70ea002250889ddcd7b7b9d776854b4943693fb92f76b4ba856ade7677bf30307b21f3ccda35d2f63aee81efd0bab6972cc0795db552927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #104: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3c80de54cd9226989443d593fa4fd6597e280ebeffffffffc1847eb76c217a95479e1ded14bcaed0379ba8e1b73d3115d84d31d4b7c30e1f05e1fc0d5957cfb0918f79e35b3d89487cf634a4f05b2e0c30857ca879f97c771e877027355b24432927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #105: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de21754e29b85601980bef3d697ea2770ce891a8cdffffffffc7906aa794b39b43dfccd0edb9e280d9a58f01164d55c3d711e14b12ac5cf3b64840ead512a0a31dbe33fa8ba84533cd5c4934365b3442ca1174899b78ef9a3199f495843897722927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #106: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8f65d92927cfb86a84dd59623fb531bb599e4d5f7289ffffffff2f1f2f57881c5b09ab637bd4caf0f4c7c7e4bca592fea20e9087c259d26a38bb4085f0bbff1145b7eb467b6748af618e9d80d6fdcd6aa24964e5a13f885bca8101de08eb0d752927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #107: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "6b63e9a74e092120160bea3877dace8a2cc7cd0e8426cbfffffffffafc8c3ca85e9b1c5a028070df5728c5c8af9b74e0667afa570a6cfa0114a5039ed15ee06fb1360907e2d9785ead362bb8d7bd661b6c29eeffd3c5037744edaeb9ad990c202927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #108: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "fc28259702a03845b6d75219444e8b43d094586e249c8699ffffffffe852512e0671a0a85c2b72d54a2fb0990e34538b4890050f5a5712f6d1a7a5fb8578f32edb1846bab6b7361479ab9c3285ca41291808f27fd5bd4fdac720e5854713694c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #109: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "1273b4502ea4e3bccee044ee8e8db7f774ecbcd52e8ceb571757ffffffffe20a7673f8526748446477dbbb0590a45492c5d7d69859d301abbaedb35b2095103a3dc70ddf9c6b524d886bed9e6af02e0e4dec0d417a414fed3807ef4422913d7c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #110: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "08fb565610a79baa0c566c66228d81814f8c53a15b96e602fb49ffffffffff6e7f085441070ecd2bb21285089ebb1aa6450d1a06c36d3ff39dfd657a796d12b5249712012029870a2459d18d47da9aa492a5e6cb4b2d8dafa9e4c5c54a2b9a8b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #111: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d59291cc2cf89f3087715fcb1aa4e79aa2403f748e97d7cd28ecaefeffffffff914c67fb61dd1e27c867398ea7322d5ab76df04bc5aa6683a8e0f30a5d287348fa07474031481dda4953e3ac1959ee8cea7e66ec412b38d6c96d28f6d37304ea2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #112: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000004319055358e8617b0c46353d039cdaabffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e0ad99500288d466940031d72a9f5445a4d43784640855bf0a69874d2de5fe103c5011e6ef2c42dcd50d5d3d29f99ae6eba2c80c9244f4c5422f0979ff0c3ba5e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #113: k*G has a large x-coordinate",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000fffffffffffffffffffffffcffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e0ad99500288d466940031d72a9f5445a4d43784640855bf0a69874d2de5fe103c5011e6ef2c42dcd50d5d3d29f99ae6eba2c80c9244f4c5422f0979ff0c3ba5e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #114: r too large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254fffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254eab05fd9d0de26b9ce6f4819652d9fc69193d0aa398f0fba8013e09c58220455419235271228c786759095d12b75af0692dd4103f19f6a8c32f49435a1e9b8d45",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #115: r,s are large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd909135bdb6799286170f5ead2de4f6511453fe50914f3df2de54a36383df8dd480984f39a1ff38a86a68aa4201b6be5dfbfecf876219710b07badf6fdd4c6c5611feb97390d9826e7a06dfb41871c940d74415ed3cac2089f1445019bb55ed95",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #116: r and s^-1 have a large Hamming weight",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd27b4577ca009376f71303fd5dd227dcef5deb773ad5f5a84360644669ca249a54201b4272944201c3294f5baa9a3232b6dd687495fcc19a70a95bc602b4f7c0595c37eba9ee8171c1bb5ac6feaf753bc36f463e3aef16629572c0c0a8fb0800e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #117: r and s^-1 have a large Hamming weight",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502300000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000001a71af64de5126a4a4e02b7922d66ce9415ce88a4c9d25514d91082c8725ac9575d47723c8fbe580bb369fec9c2665d8e30a435b9932645482e7c9f11e872296b",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #118: small r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000036627cec4f0731ea23fc2931f90ebe5b7572f597d20df08fc2b31ee8ef16b15726170ed77d8d0a14fc5c9c3c4c9be7f0d3ee18f709bb275eaf2073e258fe694a5",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #120: small r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000055a7c8825e85691cce1f5e7544c54e73f14afc010cb731343262ca7ec5a77f5bfef6edf62a4497c1bd7b147fb6c3d22af3c39bfce95f30e13a16d3d7b2812f813",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #122: small r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502300000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006cbe0c29132cd738364fedd603152990c048e5e2fff996d883fa6caca7978c73770af6a8ce44cb41224b2603606f4c04d188e80bff7cc31ad5189d4ab0d70e8c1",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #124: small r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325560000000000000000000000000000000000000000000000000000000000000006cbe0c29132cd738364fedd603152990c048e5e2fff996d883fa6caca7978c73770af6a8ce44cb41224b2603606f4c04d188e80bff7cc31ad5189d4ab0d70e8c1",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #126: r is larger than n",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000005ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc75fbd84be4178097002f0deab68f0d9a130e0ed33a6795d02a20796db83444b037e13920f13051e0eecdcfce4dacea0f50d1f247caa669f193c1b4075b51ae296d2d56",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #127: s is larger than n",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502300000000000000000000000000000000000000000000000000000000000001008f1e3c7862c58b16bb76eddbb76eddbb516af4f63f2d74d76e0d28c9bb75ea88d0f73792203716afd4be4329faa48d269f15313ebbba379d7783c97bf3e890d9971f4a3206605bec21782bf5e275c714417e8f566549e6bc68690d2363c89cc1",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #128: small r and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000000000000000002d9b4d347952d6ef3043e7329581dbb3974497710ab11505ee1c87ff907beebadd195a0ffe6d7a4838b2be35a6276a80ef9e228140f9d9b96ce83b7a254f71ccdebbb8054ce05ffa9cbc123c919b19e00238198d04069043bd660a828814051fcb8aac738a6c6b",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #129: smallish r and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000001033e67e37b32b445580bf4eff8b748b74000000008b748b748b748b7466e769ad4a16d3dcd87129b8e91d1b4d7393983ca30a520bbc4783dc9960746aab444ef520c0a8e771119aa4e74b0f64e9d7be1ab01a0bf626e709863e6a486dbaf32793afccf774e2c6cd27b1857526",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #130: 100-bit r and small s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000100ef9f6ba4d97c09d03178fa20b4aaad83be3cf9cb824a879fec3270fc4b81ef5b5ac331a1103fe966697379f356a937f350588a05477e308851b8a502d5dfcdc5fe9993df4b57939b2b8da095bf6d794265204cfe03be995a02e65d408c871c0b",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #131: small r and 100 bit s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502300000000000000000000000000000000000000062522bbd3ecbe7c39e93e7c25ef9f6ba4d97c09d03178fa20b4aaad83be3cf9cb824a879fec3270fc4b81ef5b1d209be8de2de877095a399d3904c74cc458d926e27bb8e58e5eae5767c41509dd59e04c214f7b18dce351fc2a549893a6860e80163f38cc60a4f2c9d040d8c9",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #132: 100-bit r and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6324d5555555550000000055555555555555553ef7a8e48d07df81a693439654210c70083539fbee44625e3acaafa2fcb41349392cef0633a1b8fabecee0c133b10e99915c1ebe7bf00df8535196770a58047ae2a402f26326bb7d41d4d7616337911e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #133: r and s^-1 are close to n",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c7000000000000000000000000000000000000000000000000000000000000000018aeb368a7027a4d64abdea37390c0c1d6a26f399e2d9734de1eb3d0e1937387405bd13834715e1dbae9b875cf07bd55e1b6691c7f7536aef3b19bf7a4adf576d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #134: s == 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c7000000000000000000000000000000000000000000000000000000000000000008aeb368a7027a4d64abdea37390c0c1d6a26f399e2d9734de1eb3d0e1937387405bd13834715e1dbae9b875cf07bd55e1b6691c7f7536aef3b19bf7a4adf576d",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #135: s == 0",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a8555555550000000055555555555555553ef7a8e48d07df81a693439654210c70b533d4695dd5b8c5e07757e55e6e516f7e2c88fa0239e23f60e8ec07dd70f2871b134ee58cc583278456863f33c3a85d881f7d4a39850143e29d4eaf009afe47",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #136: point at infinity during verify",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a97fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a8f50d371b91bfb1d7d14e1323523bc3aa8cbf2c57f9e284de628c8b4536787b86f94ad887ac94d527247cd2e7d0c8b1291c553c9730405380b14cbb209f5fa2dd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #137: edge case for signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a97fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a968ec6e298eafe16539156ce57a14b04a7047c221bafc3a582eaeb0d857c4d94697bed1af17850117fdb39b2324f220a5698ed16c426a27335bb385ac8ca6fb30",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #138: edge case for signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c70bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502369da0364734d2e530fece94019265fefb781a0f1b08f6c8897bdf6557927c8b866d2d3c7dcd518b23d726960f069ad71a933d86ef8abbcce8b20f71e2a847002",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #139: u1 == 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c7044a5ad0ad0636d9f12bc9e0a6bdd5e1cbcb012ea7bf091fcec15b0c43202d52ed8adc00023a8edc02576e2b63e3e30621a471e2b2320620187bf067a1ac1ff3233e2b50ec09807accb36131fff95ed12a09a86b4ea9690aa32861576ba2362e1",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #140: u1 == n - 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c70555555550000000055555555555555553ef7a8e48d07df81a693439654210c703623ac973ced0a56fa6d882f03a7d5c7edca02cfc7b2401fab3690dbe75ab7858db06908e64b28613da7257e737f39793da8e713ba0643b92e9bb3252be7f8fe",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #141: u2 == 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c70aaaaaaaa00000000aaaaaaaaaaaaaaaa7def51c91a0fbf034d26872ca84218e1cf04ea77e9622523d894b93ff52dc3027b31959503b6fa3890e5e04263f922f1e8528fb7c006b3983c8b8400e57b4ed71740c2f3975438821199bedeaecab2e9",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #142: u2 == n - 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffde91e1ba60fdedb76a46bcb51dc0b8b4b7e019f0a28721885fa5d3a8196623397db7a2c8a1ab573e5929dc24077b508d7e683d49227996bda3e9f78dbeff773504f417f3bc9a88075c2e0aadd5a13311730cf7cc76a82f11a36eaf08a6c99a206",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #143: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdfdea5843ffeb73af94313ba4831b53fe24f799e525b1e8e8c87b59b95b430ad9dead11c7a5b396862f21974dc4752fadeff994efe9bbd05ab413765ea80b6e1f1de3f0640e8ac6edcf89cff53c40e265bb94078a343736df07aa0318fc7fe1ff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #144: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd03ffcabf2f1b4d2a65190db1680d62bb994e41c5251cd73b3c3dfc5e5bafc035d0bc472e0d7c81ebaed3a6ef96c18613bb1fea6f994326fbe80e00dfde67c7e9986c723ea4843d48389b946f64ad56c83ad70ff17ba85335667d1bb9fa619efd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #145: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd4dfbc401f971cd304b33dfdb17d0fed0fe4c1a88ae648e0d2847f74977534989a0a44ca947d66a2acb736008b9c08d1ab2ad03776e02640f78495d458dd51c326337fe5cf8c4604b1f1c409dc2d872d4294a4762420df43a30a2392e40426add",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #146: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbc4024761cd2ffd43dfdb17d0fed112b988977055cd3a8e54971eba9cda5ca71c9c2115290d008b45fb65fad0f602389298c25420b775019d42b62c3ce8a96b73877d25a8080dc02d987ca730f0405c2c9dbefac46f9e601cc3f06e9713973fd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #147: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd788048ed39a5ffa77bfb62fa1fda2257742bf35d128fb3459f2a0c909ee86f915eca1ef4c287dddc66b8bccf1b88e8a24c0018962f3c5e7efa83bc1a5ff6033e5e79c4cb2c245b8c45abdce8a8e4da758d92a607c32cd407ecaef22f1c934a71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #148: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd476d9131fd381bd917d0fed112bc9e0a5924b5ed5b11167edd8b23582b3cb15e5caaa030e7fdf0e4936bc7ab5a96353e0a01e4130c3f8bf22d473e317029a47adeb6adc462f7058f2a20d371e9702254e9b201642005b3ceda926b42b178bef9",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #149: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd8374253e3e21bd154448d0a8f640fe46fafa8b19ce78d538f6cc0a19662d3601c2fd20bac06e555bb8ac0ce69eb1ea20f83a1fc3501c8a66469b1a31f619b0986237050779f52b615bd7b8d76a25fc95ca2ed32525c75f27ffc87ac397e6cbaf",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #150: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd357cfd3be4d01d413c5b9ede36cba5452c11ee7fe14879e749ae6a2d897a52d63fd6a1ca7f77fb3b0bbe726c372010068426e11ea6ae78ce17bedae4bba86ced03ce5516406bf8cfaab8745eac1cd69018ad6f50b5461872ddfc56e0db3c8ff4",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #151: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd29798c5c0ee287d4a5e8e6b799fd86b8df5225298e6ffc807cd2f2bc27a0a6d89cb8e51e27a5ae3b624a60d6dc32734e4989db20e9bca3ede1edf7b086911114b4c104ab3c677e4b36d6556e8ad5f523410a19f2e277aa895fc57322b4427544",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #152: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd0b70f22c781092452dca1a5711fa3a5a1f72add1bf52c2ff7cae4820b30078dda3e52c156dcaf10502620b7955bc2b40bc78ef3d569e1223c262512d8f49602a4a2039f31c1097024ad3cc86e57321de032355463486164cf192944977df147f",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #153: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd16e1e458f021248a5b9434ae23f474b43ee55ba37ea585fef95c90416600f1baf19b78928720d5bee8e670fb90010fb15c37bf91b58a5157c3f3c059b2655e88cf701ec962fb4a11dcf273f5dc357e58468560c7cfeb942d074abd4329260509",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #154: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd2252d6856831b6cf895e4f0535eeaf0e5e5809753df848fe760ad86219016a9783a744459ecdfb01a5cf52b27a05bb7337482d242f235d7b4cb89345545c90a8c05d49337b9649813287de9ffe90355fd905df5f3c32945828121f37cc50de6e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #155: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd81ffe55f178da695b28c86d8b406b15dab1a9e39661a3ae017fbe390ac0972c3dd13c6b34c56982ddae124f039dfd23f4b19bbe88cee8e528ae51e5d6f3a21d7bfad4c2e6f263fe5eb59ca974d039fc0e4c3345692fb5320bdae4bd3b42a45ff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #156: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd7fffffffaaaaaaaaffffffffffffffffe9a2538f37b28a2c513dee40fecbb71a67e6f659cdde869a2f65f094e94e5b4dfad636bbf95192feeed01b0f3deb7460a37e0a51f258b7aeb51dfe592f5cfd5685bbe58712c8d9233c62886437c38ba0",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #157: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdb62f26b5f2a2b26f6de86d42ad8a13da3ab3cccd0459b201de009e526adf21f22eb6412505aec05c6545f029932087e490d05511e8ec1f599617bb367f9ecaaf805f51efcc4803403f9b1ae0124890f06a43fedcddb31830f6669af292895cb0",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #158: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbb1d9ac949dd748cd02bbbe749bd351cd57b38bb61403d700686aa7b4c90851e84db645868eab35e3a9fd80e056e2e855435e3a6b68d75a50a854625fe0d7f356d2589ac655edc9a11ef3e075eddda9abf92e72171570ef7bf43a2ee39338cfe",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #159: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd66755a00638cdaec1c732513ca0234ece52545dac11f816e818f725b4f60aaf291b9e47c56278662d75c0983b22ca8ea6aa5059b7a2ff7637eb2975e386ad66349aa8ff283d0f77c18d6d11dc062165fd13c3c0310679c1408302a16854ecfbd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #160: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd55a00c9fcdaebb6032513ca0234ecfffe98ebe492fdf02e48ca48e982beb3669f3ec2f13caf04d0192b47fb4c5311fb6d4dc6b0a9e802e5327f7ec5ee8e4834df97e3e468b7d0db867d6ecfe81e2b0f9531df87efdb47c1338ac321fefe5a432",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #161: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdab40193f9b5d76c064a27940469d9fffd31d7c925fbe05c919491d3057d66cd2d92b200aefcab6ac7dafd9acaf2fa10b3180235b8f46b4503e4693c670fccc885ef2f3aebf5b317475336256768f7c19efb7352d27e4cccadc85b6b8ab922c72",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #162: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdca0234ebb5fdcb13ca0234ecffffffffcb0dadbbc7f549f8a26b4408d0dc86000a88361eb92ecca2625b38e5f98bbabb96bf179b3d76fc48140a3bcd881523cde6bdf56033f84a5054035597375d90866aa2c96b86a41ccf6edebf47298ad489",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #163: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff3ea3677e082b9310572620ae19933a9e65b285598711c77298815ad3d0fb17ccd8fafe827e0c1afc5d8d80366e2b20e7f14a563a2ba50469d84375e868612569d39e2bb9f554355564646de99ac602cc6349cf8c1e236a7de7637d93",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #164: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd266666663bbbbbbbe6666666666666665b37902e023fab7c8f055d86e5cc41f4836f33bbc1dc0d3d3abbcef0d91f11e2ac4181076c9af0a22b1e4309d3edb2769ab443ff6f901e30c773867582997c2bec2b0cb8120d760236f3a95bbe881f75",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #165: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff36db6db7a492492492492492146c573f4c6dfc8d08a443e258970b0992f99fbe973ed4a299719baee4b432741237034dec8d72ba5103cb33e55feeb8033dd0e91134c734174889f3ebcf1b7a1ac05767289280ee7a794cebd6e69697",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #166: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff2aaaaaab7fffffffffffffffc815d0e60b3e596ecb1ad3a27cfd49c4d35ba58da30197d378e618ec0fa7e2e2d12cffd73ebbb2049d130bba434af09eff83986e6875e41ea432b7585a49b3a6c77cbb3c47919f8e82874c794635c1d2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #167: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd7fffffff55555555ffffffffffffffffd344a71e6f651458a27bdc81fd976e378651ce490f1b46d73f3ff475149be29136697334a519d7ddab0725c8d0793224e11c65bd8ca92dc8bc9ae82911f0b52751ce21dd9003ae60900bd825f590cc28",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #168: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd3fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192aa6d8e1b12c831a0da8795650ff95f101ed921d9e2f72b15b1cdaca9826b9cfc6def6d63e2bc5c089570394a4bc9f892d5e6c7a6a637b20469a58c106ad486bf37",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #169: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd5d8ecd64a4eeba466815ddf3a4de9a8e6abd9c5db0a01eb80343553da648428f0ae580bae933b4ef2997cbdbb0922328ca9a410f627a0f7dff24cb4d920e15428911e7f8cc365a8a88eb81421a361ccc2b99e309d8dcd9a98ba83c3949d893e3",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #170: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236f2347cab7dd76858fe0555ac3bc99048c4aacafdfb6bcbe05ea6c42c4934569bb726660235793aa9957a61e76e00c2c435109cf9a15dd624d53f4301047856b5b812fd521aafa69835a849cce6fbdeb6983b442d2444fe70e134c027fc46963838a40f2a36092e9004e92d8d940cf5638550ce672ce8b8d4e15eba5499249e9",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #171: point duplication during verification",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236f2347cab7dd76858fe0555ac3bc99048c4aacafdfb6bcbe05ea6c42c4934569bb726660235793aa9957a61e76e00c2c435109cf9a15dd624d53f4301047856b5b812fd521aafa69835a849cce6fbdeb6983b442d2444fe70e134c027fc469637c75bf0c5c9f6d17ffb16d2726bf30a9c7aaf31a8d317472b1ea145ab66db616",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #172: duplication bug",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000001555555550000000055555555555555553ef7a8e48d07df81a693439654210c706adda82b90261b0f319faa0d878665a6b6da497f09c903176222c34acfef72a647e6f50dcc40ad5d9b59f7602bb222fad71a41bf5e1f9df4959a364c62e488d9",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #173: point with x-coordinate 0",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c703333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aa9dd86d3b5f4a13e8511083b78002081c53ff467f11ebd98a51a633db76665d25045d5c8200c89f2fa10d849349226d21d8dfaed6ff8d5cb3e1b7e17474ebc18f7",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #175: comparison with point at infinity ",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978555555550000000055555555555555553ef7a8e48d07df81a693439654210c704fea55b32cb32aca0c12c4cd0abfb4e64b0f5a516e578c016591a93f5a0fbcc5d7d3fd10b2be668c547b212f6bb14c88f0fecd38a8a4b2c785ed3be62ce4b280",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #176: extreme value for k and edgecase s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978b6db6db6249249254924924924924924625bd7a09bec4ca81bcdd9f8fd6b63ccc6a771527024227792170a6f8eee735bf32b7f98af669ead299802e32d7c3107bc3b4b5e65ab887bbd343572b3e5619261fe3a073e2ffd78412f726867db589e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #177: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978cccccccc00000000cccccccccccccccc971f2ef152794b9d8fc7d568c9e8eaa7851c2bbad08e54ec7a9af99f49f03644d6ec6d59b207fec98de85a7d15b956efcee9960283045075684b410be8d0f7494b91aa2379f60727319f10ddeb0fe9d6",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #178: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc476699783333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aaaf6417c8a670584e388676949e53da7fc55911ff68318d1bf3061205acb19c48f8f2b743df34ad0f72674acb7505929784779cd9ac916c3669ead43026ab6d43f",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #179: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc4766997849249248db6db6dbb6db6db6db6db6db5a8b230d0b2b51dcd7ebf0c9fef7c185501421277be45a5eefec6c639930d636032565af420cf3373f557faa7f8a06438673d6cb6076e1cfcdc7dfe7384c8e5cac08d74501f2ae6e89cad195d0aa1371",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #180: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc4766997816a4502e2781e11ac82cbc9d1edd8c981584d13e18411e2f6e0478c34416e3bb0d935bf9ffc115a527735f729ca8a4ca23ee01a4894adf0e3415ac84e808bb343195a3762fea29ed38912bd9ea6c4fde70c3050893a4375850ce61d82eba33c5",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #181: extreme value for k",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296555555550000000055555555555555553ef7a8e48d07df81a693439654210c705e59f50708646be8a589355014308e60b668fb670196206c41e748e64e4dca215de37fee5c97bcaf7144d5b459982f52eeeafbdf03aacbafef38e213624a01de",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #182: extreme value for k and edgecase s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b6db6db6249249254924924924924924625bd7a09bec4ca81bcdd9f8fd6b63cc169fb797325843faff2f7a5b5445da9e2fd6226f7ef90ef0bfe924104b02db8e7bbb8de662c7b9b1cf9b22f7a2e582bd46d581d68878efb2b861b131d8a1d667",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #183: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296cccccccc00000000cccccccccccccccc971f2ef152794b9d8fc7d568c9e8eaa7271cd89c000143096b62d4e9e4ca885aef2f7023d18affdaf8b7b548981487540a1c6e954e32108435b55fa385b0f76481a609b9149ccb4b02b2ca47fe8e4da5",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #184: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2963333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aaa3d0bc7ed8f09d2cb7ddb46ebc1ed799ab1563a9ab84bf524587a220afe499c12e22dc3b3c103824a4f378d96adb0a408abf19ce7d68aa6244f78cb216fa3f8df",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #185: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c29649249248db6db6dbb6db6db6db6db6db5a8b230d0b2b51dcd7ebf0c9fef7c185a6c885ade1a4c566f9bb010d066974abb281797fa701288c721bcbd23663a9b72e424b690957168d193a6096fc77a2b004a9c7d467e007e1f2058458f98af316",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #186: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c29616a4502e2781e11ac82cbc9d1edd8c981584d13e18411e2f6e0478c34416e3bb8d3c2c2c3b765ba8289e6ac3812572a25bf75df62d87ab7330c3bdbad9ebfa5c4c6845442d66935b238578d43aec54f7caa1621d1af241d4632e0b780c423f5d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #187: extreme value for k",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2964fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #188: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502344a5ad0ad0636d9f12bc9e0a6bdd5e1cbcb012ea7bf091fcec15b0c43202d52e249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2964fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #189: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b01cbd1c01e58065711814b583f061e9d431cca994cea1313449bf97c840ae0a",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #190: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502344a5ad0ad0636d9f12bc9e0a6bdd5e1cbcb012ea7bf091fcec15b0c43202d52e249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b01cbd1c01e58065711814b583f061e9d431cca994cea1313449bf97c840ae0a",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #191: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855b292a619339f6e567a305c951c0dcbcc42d16e47f219f9e98e76e09d8770b34a0177e60492c5a8242f76f07bfe3661bde59ec2a17ce5bd2dab2abebdf89a62e204aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #192: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "dc1921946f4af96a2856e7be399007c9e807bdf4c5332f19f59ec9dd1bb8c7b3530bd6b0c9af2d69ba897f6b5fb59695cfbf33afe66dbadcf5b8d2a2a6538e23d85e489cb7a161fd55ededcedbf4cc0c0987e3e3f0f242cae934c72caa3f43e904aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #193: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023a8ea150cb80125d7381c4c1f1da8e9de2711f9917060406a73d7904519e51388f3ab9fa68bd47973a73b2d40480c2ba50c22c9d76ec217257288293285449b8604aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #194: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de47c9b27eb8d300dbb5f2c353e632c393262cf06340c4fa7f1b40c4cbd36f90986e65933ef2ed4ee5aada139f52b70539aaf63f00a91f29c69178490d57fb713dafedfb8da6189d372308cbf1489bbbdabf0c0217d1c0ff0f701aaa7a694b9c04aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #195: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d434e262a49eab7781e353a3565e482550dd0fd5defa013c7f29745eff3569f19b0c0a93f267fb6052fd8077be769c2b98953195d7bc10de844218305c6ba17a4f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #196: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f910fe774355c04d060f76d79fd7a772e421463489221bf0a33add0be9b1979110b500dcba1c69a8fbd43fa4f57f743ce124ca8b91a1f325f3fac6181175df557374f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #197: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91bb40bf217bed3fb3950c7d39f03d36dc8e3b2cd79693f125bfd06595ee1135e3541bf3532351ebb032710bdb6a1bf1bfc89a1e291ac692b3fa4780745bb556774f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #198: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91664eb7ee6db84a34df3c86ea31389a5405badd5ca99231ff556d3e75a233e73a59f3c752e52eca46137642490a51560ce0badc678754b8f72e51a2901426a1bd3cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #199: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f914cd0429bbabd2827009d6fcd843d4ce39c3e42e2d1631fd001985a79d1fd8b439638bf12dd682f60be7ef1d0e0d98f08b7bca77a1a2b869ae466189d2acdabe33cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #200: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91e56c6ea2d1b017091c44d8b6cb62b9f460e3ce9aed5e5fd41e8added97c56c04a308ec31f281e955be20b457e463440b4fcf2b80258078207fc1378180f89b553cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #201: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f911158a08d291500b4cabed3346d891eee57c176356a2624fb011f8fbbf3466830228a8c486a736006e082325b85290c5bc91f378b75d487dda46798c18f2855193cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #202: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b1db9289649f59410ea36b0c0fc8d6aa2687b29176939dd23e0dde56d309fa9d3e1535e4280559015b0dbd987366dcf43a6d1af5c23c7d584e1c3f48a12513363cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #203: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b7b16e762286cb96446aa8d4e6e7578b0a341a79f2dd1a220ac6f0ca4e24ed86ddc60a700a139b04661c547d07bbb0721780146df799ccf55e55234ecb8f12bc3cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #204: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d82a7c2717261187c8e00d8df963ff35d796edad36bc6e6bd1c91c670d9105b43dcabddaf8fcaa61f4603e7cbac0f3c0351ecd5988efb23f680d07debd1399292829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #205: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f915eb9c8845de68eb13d5befe719f462d77787802baff30ce96a5cba063254af782c026ae9be2e2a5e7ca0ff9bbd92fb6e44972186228ee9a62b87ddbe2ef66fb52829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #206: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9196843dd03c22abd2f3b782b170239f90f277921becc117d0404a8e4e36230c28f2be378f526f74a543f67165976de9ed9a31214eb4d7e6db19e1ede123dd991d2829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #207: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91766456dce1857c906f9996af729339464d27e9d98edc2d0e3b760297067421f6402385ecadae0d8081dccaf5d19037ec4e55376eced699e93646bfbbf19d0b41fffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #208: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91c605c4b2edeab20419e6518a11b2dbc2b97ed8b07cced0b19c34f777de7b9fd9edf0f612c5f46e03c719647bc8af1b29b2cde2eda700fb1cff5e159d47326dbafffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #209: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d48b68e6cabfe03cf6141c9ac54141f210e64485d9929ad7b732bfe3b7eb8a84feedae50c61bd00e19dc26f9b7e2265e4508c389109ad2f208f0772315b6c941fffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #210: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b7c81457d4aeb6aa65957098569f0479710ad7f6595d5874c35a93d12a5dd4c7b7961a0b652878c2d568069a432ca18a1a9199f2ca574dad4b9e3a05c0a1cdb300000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #211: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f916b01332ddb6edfa9a30a1321d5858e1ee3cf97e263e669f8de5e9652e76ff3f75939545fced457309a6a04ace2bd0f70139c8f7d86b02cb1cc58f9e69e96cd5a00000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #212: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91efdb884720eaeadc349f9fc356b6c0344101cd2fd8436b7d0e6a4fb93f106361f24bee6ad5dc05f7613975473aadf3aacba9e77de7d69b6ce48cb60d8113385d00000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #213: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9131230428405560dcb88fb5a646836aea9b23a23dd973dcbe8014c87b8b20eb070f9344d6e812ce166646747694a41b0aaf97374e19f3c5fb8bd7ae3d9bd0beffbcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #214: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91caa797da65b320ab0d5c470cda0b36b294359c7db9841d679174db34c4855743cf543a62f23e212745391aaf7505f345123d2685ee3b941d3de6d9b36242e5a0bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #215: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f917e5f0ab5d900d3d3d7867657e5d6d36519bc54084536e7d21c336ed8001859459450c07f201faec94b82dfb322e5ac676688294aad35aa72e727ff0b19b646aabcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #216: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d7d70c581ae9e3f66dc6a480bf037ae23f8a1e4a2136fe4b03aa69f0ca25b35689c460f8a5a5c2bbba962c8a3ee833a413e85658e62a59e2af41d9127cc47224bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #217: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91341c1b9ff3c83dd5e0dfa0bf68bcdf4bb7aa20c625975e5eeee34bb396266b3472b69f061b750fd5121b22b11366fad549c634e77765a017902a67099e0a4469bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #218: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9170bebe684cdcb5ca72a42f0d873879359bd1781a591809947628d313a3814f67aec03aca8f5587a4d535fa31027bbe9cc0e464b1c3577f4c2dcde6b2094798a9bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_p1363_test.json EcdsaP1363Verify SHA-256 #219: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e184cd60b855d442f5b3c7b11eb6c4e0ae7525fe710fab9aa7c77a67f79e6fadd762927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #1: signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e18b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #2: Legacy:ASN encoding of s misses leading 0",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e18b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #3: valid",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502329a3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e18b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #118: modify first byte of integer",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e98b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #120: modify last byte of integer",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e18b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b491568475b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #121: modify last byte of integer",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e1800b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b491568472927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #124: truncated integer",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023d45c5741946b2a137f59262ee6f5bc91001af27a5e1117a64733950642a3d1e8b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #133: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023d45c5740946b2a147f59262ee6f5bc90bd01ed280528b62b3aed5fc93f06f739b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #134: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023d45c5741946b2a137f59262ee6f5bc91001af27a5e1117a64733950642a3d1e8b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #137: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e18b329f47aa2bbd0a4c384ee1493b1f518ada018ef05465583885980861905228a2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #139: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e184cd60b865d442f5a3c7b11eb6c4e0ae79578ec6353a20bf783ecb4b6ea97b8252927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #143: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #177: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #178: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #179: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #180: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #181: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #187: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #188: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #189: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #190: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #191: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #197: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #198: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #199: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #200: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #201: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #207: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #208: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #209: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #210: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #211: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #217: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #218: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #219: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #220: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #221: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "70239dd877f7c944c422f44dea4ed1a52f2627416faf2f072fa50c772ed6f80764a1aab5000d0e804f3e2fc02bdee9be8ff312334e2ba16d11547c97711c898e6af015971cc30be6d1a206d4e013e0997772a2f91d73286ffd683b9bb2cf4f1b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #230: Edge case for Shamir multiplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "00000000690ed426ccf17803ebe2bd0884bcd58a1bb5e7477ead3645f356e7a916aea964a2f6506d6f78c81c91fc7e8bded7d397738448de1e19a0ec580bf266252cd762130c6667cfe8b7bc47d27d78391e8e80c578d1cd38c3ff033be928e92927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #231: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7300000000213f2a525c6035725235c2f696ad3ebb5ee47f140697ad25770d919cc98be2347d469bf476dfc26b9b733df2d26d6ef524af917c665baccb23c882093496459effe2d8d70727b82462f61d0ec1b7847929d10ea631dacb16b56c322927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #232: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ddf2000000005e0be0635b245f0b97978afd25daadeb3edb4a0161c27fe0604573b3c90ecd390028058164524dde892703dce3dea0d53fa8093999f07ab8aa432f67b0b8e20636695bb7d8bf0a651c802ed25a395387b5f4188c0c4075c886342927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #233: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "67ab1900000000784769c4ecb9e164d6642b8499588b89855be1ec355d0841a0bfab3098252847b328fadf2f89b95c851a7f0eb390763378f37e90119d5ba3ddbdd64e234e832b1067c2d058ccb44d978195ccebb65c2aaf1e2da9b8b4987e3b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #234: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a2bf09460000000076d7dbeffe125eaf02095dff252ee905e296b6350fc311cf204a9784074b246d8bf8bf04a4ceb1c1f1c9aaab168b1596d17093c5cd21d2cd51cce41670636783dc06a759c8847868a406c2506fe17975582fe648d1d88b522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #235: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3554e827c700000000e1e75e624a06b3a0a353171160858129e15c544e4f0e65ed66dc34f551ac82f63d4aa4f81fe2cb0031a91d1314f835027bca0f1ceeaa0399ca123aa09b13cd194a422e18d5fda167623c3f6e5d4d6abb8953d67c0c48c72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #236: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9b6cd3b812610000000026941a0f0bb53255ea4c9fd0cb3426e3a54b9fc6965c060b700bef665c68899d44f2356a578d126b062023ccc3c056bf0f60a237012b8d186c027832965f4fcc78a3366ca95dedbb410cbef3f26d6be5d581c11d36102927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #237: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "883ae39f50bf0100000000e7561c26fc82a52baa51c71ca877162f93c4ae01869f6adfe8d5eb5b2c24d7aa7934b6cf29c93ea76cd313c9132bb0c8e38c96831db26a9c9e40e55ee0890c944cf271756c906a33e66b5bd15e051593883b5e99022927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #238: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a1ce5d6e5ecaf28b0000000000fa7cd010540f420fb4ff7401fe9fce011d0ba6a1af03ca91677b673ad2f33615e56174a1abf6da168cebfa8868f4ba273f16b720aa73ffe48afa6435cd258b173d0c2377d69022e7d098d75caf24c8c5e06b1c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #239: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8ea5f645f373f580930000000038345397330012a8ee836c5494cdffd5ee8054fdc70602766f8eed11a6c99a71c973d5659355507b843da6e327a28c11893db93df5349688a085b137b1eacf456a9e9e0f6d15ec0078ca60a7f83f2b10d213502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #240: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "660570d323e9f75fa734000000008792d65ce93eabb7d60d8d9c1bbdcb5ef305b516a314f2fce530d6537f6a6c49966c23456f63c643cf8e0dc738f7b876e675d39ffd033c92b6d717dd536fbc5efdf1967c4bd80954479ba66b0120cd16fff22927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #241: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d0462673154cce587dde8800000000e98d35f1f45cf9c3bf46ada2de4c568c343b2cbf046eac45842ecb7984d475831582717bebb6492fd0a485c101e29ff0a84c9b7b47a98b0f82de512bc9313aaf51701099cac5f76e68c8595fc1c1d992582927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #242: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bd90640269a7822680cedfef000000000caef15a6171059ab83e7b4418d7278f30c87d35e636f540841f14af54e2f9edd79d0312cfa1ab656c3fb15bfde48dcf47c15a5a82d24b75c85a692bd6ecafeb71409ede23efd08e0db9abf6340677ed2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #243: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "33239a52d72f1311512e41222a00000000d2dcceb301c54b4beae8e284788a7338686ff0fda2cef6bc43b58cfe6647b9e2e8176d168dec3c68ff262113760f52067ec3b651f422669601662167fa8717e976e2db5e6a4cf7c2ddabb3fde9d67d2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #244: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "b8d64fbcd4a1c10f1365d4e6d95c000000007ee4a21a1cbe1dc84c2d941ffaf144a3e23bf314f2b344fc25c7f2de8b6af3e17d27f5ee844b225985ab6e2775cf2d48e223205e98041ddc87be532abed584f0411f5729500493c9cc3f4dd15e862927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #245: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "01603d3982bf77d7a3fef3183ed092000000003a227420db4088b20fe0e9d84a2ded5b7ec8e90e7bf11f967a3d95110c41b99db3b5aa8d330eb9d638781688e97d5792c53628155e1bfc46fb1a67e3088de049c328ae1f44ec69238a009808f92927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #246: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9ea6994f1e0384c8599aa02e6cf66d9c000000004d89ef50b7e9eb0cfbff7363bdae7bcb580bf335efd3bc3d31870f923eaccafcd40ec2f605976f15137d8b8ff6dfa12f19e525270b0106eecfe257499f373a4fb318994f24838122ce7ec3c72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #247: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d03215a8401bcf16693979371a01068a4700000000e2fa5bf692bc670905b18c50f9c4f0cd6940e162720957ffff513799209b78596956d21ece251c2401f1c6d7033a0a787d338e889defaaabb106b95a4355e411a59c32aa5167dfab2447262927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #248: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "307bfaaffb650c889c84bf83f0300e5dc87e000000008408fd5f64b582e3bb14f612820687604fa01906066a378d67540982e29575d019aabe90924ead5c860d3f9367702dd7dd4f75ea98afd20e328a1a99f4857b316525328230ce294b0fef2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #249: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bab5c4f4df540d7b33324d36bb0c157551527c00000000e4af574bb4d54ea6b89505e407657d6e8bc93db5da7aa6f5081f61980c1949f56b0f2f507da5782a7ac60d31904e3669738ffbeccab6c3656c08e0ed5cb92b3cfa5e7f71784f9c50212927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #250: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d4ba47f6ae28f274e4f58d8036f9c36ec2456f5b00000000c3b869197ef5e15ebbd16fbbb656b6d0d83e6a7787cd691b08735aed371732723e1c68a40404517d9d8e35dba96028b7787d91315be675877d2d097be5e8ee34560e3e7fd25c0f002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #251: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "79fd19c7235ea212f29f1fa00984342afe0f10aafd00000000801e47f8c184e12ec9760122db98fd06ea76848d35a6da442d2ceef7559a30cf57c61e92df327e7ab271da90859479701fccf86e462ee3393fb6814c27b760c4963625c0a198782927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #252: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8c291e8eeaa45adbaf9aba5c0583462d79cbeb7ac97300000000a37ea6700cda54e76b7683b6650baa6a7fc49b1c51eed9ba9dd463221f7a4f1005a89fe00c592ea076886c773eb937ec1cc8374b7915cfd11b1c1ae1166152f2f7806a31c8fd2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #253: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0eaae8641084fa979803efbfb8140732f4cdcf66c3f78a000000003c278a6b215291deaf24659ffbbce6e3c26f6021097a74abdbb69be4fb10419c0c496c946665d6fcf336d27cc7cdb982bb4e4ecef5827f84742f29f10abf83469270a03dc32927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #254: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "e02716d01fb23a5a0068399bf01bab42ef17c6d96e13846c00000000afc0f89d207a3241812d75d947419dc58efb05e8003b33fc17eb50f9d15166a88479f107cdee749f2e492b213ce80b32d0574f62f1c5d70793cf55e382d5caadf75927672927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #255: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9eb0bf583a1a6b9a194e9a16bc7dab2a9061768af89d00659a00000000fc7de16554e49f82a855204328ac94913bf01bbe84437a355a0a37c0dee3cf81aa7728aea00de2507ddaf5c94e1e126980d3df16250a2eaebc8be486effe7f22b4f9292927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #256: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "62aac98818b3b84a2c214f0d5e72ef286e1030cb53d9a82b690e00000000cd15a54c5062648339d2bff06f71c88216c26c6e19b4d80a8c602990ac82707efdfce99bbe7fcfafae3e69fd016777517aa01056317f467ad09aff09be73c9731b0d2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #257: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3760a7f37cf96218f29ae43732e513efd2b6f552ea4b6895464b9300000000c8975bd7157a8d363b309f1f444012b1a1d23096593133e71b4ca8b059cff37eaf7faa7a28b1c822baa241793f2abc930bd4c69840fe090f2aacc46786bf9196222927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #258: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0da0a1d2851d33023834f2098c0880096b4320bea836cd9cbb6ff6c8000000005694a6f84b8f875c276afd2ebcfe4d61de9ec90305afb1357b95b3e0da43885e0dffad9ffd0b757d8051dec02ebdf70d8ee2dc5c7870c0823b6ccc7c679cbaa42927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #259: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ffffffff293886d3086fd567aafd598f0fe975f735887194a764a231e82d289aa0c30e8026fdb2b4b4968a27d16a6d08f7098f1a98d21620d7454ba9790f1ba65e470453a8a399f15baf463f9deceb53acc5ca64459149688bd2760c654243392927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #260: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7bffffffff2376d1e3c03445a072e24326acdc4ce127ec2e0e8d9ca99527e7b7614ea84acf736527dd73602cd4bb4eea1dfebebd5ad8aca52aa0228cf7b99a88737cc85f5f2d2f60d1b8183f3ed490e4de14368e96a9482c2a4dd193195c902f2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #261: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a2b5ffffffffebb251b085377605a224bc80872602a6e467fd016807e97fa395bead6734ebe44b810d3fb2ea00b1732945377338febfd439a8d74dfbd0f942fa6bb18eae36616a7d3cad35919fd21a8af4bbe7a10f73b3e036a46b103ef56e2a2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #262: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "641227ffffffff6f1b96fa5f097fcf3cc1a3c256870d45a67b83d0967d4b20c0499625479e161dacd4db9d9ce64854c98d922cbf212703e9654fae182df9bad242c177cf37b8193a0131108d97819edd9439936028864ac195b64fca76d9d6932927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #263: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "958415d8ffffffffabad03e2fc662dc3ba203521177502298df56f36600e0f8b08f16b8093a8fb4d66a2c8065b541b3d31e3bfe694f6b89c50fb1aaa6ff6c9b29d6455e2d5d1779748573b611cb95d4a21f967410399b39b535ba3e5af81ca2e2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #264: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "f1d8de4858ffffffff1281093536f47fe13deb04e1fbe8fb954521b6975420f8be26231b6191658a19dd72ddb99ed8f8c579b6938d19bce8eed8dc2b338cb5f8e1d9a32ee56cffed37f0f22b2dcb57d5c943c14f79694a03b9c5e96952575c892927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #265: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0927895f2802ffffffff10782dd14a3b32dc5d47c05ef6f1876b95c81fc31def15e76880898316b16204ac920a02d58045f36a229d4aa4f812638c455abe0443e74d357d3fcb5c8c5337bd6aba4178b455ca10e226e13f9638196506a19391232927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #266: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "60907984aa7e8effffffff4f332862a10a57c3063fb5a30624cf6a0c3ac80589352ecb53f8df2c503a45f9846fc28d1d31e6307d3ddbffc1132315cc07f16dad1348dfa9c482c558e1d05c5242ca1c39436726ecd28258b1899792887dd0a3c62927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #267: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "c6ff198484939170ffffffff0af42cda50f9a5f50636ea6942d6b9b8cd6ae1e24a40801a7e606ba78a0da9882ab23c7677b8642349ed3d652c5bfa5f2a9558fb3a49b64848d682ef7f605f2832f7384bdc24ed2925825bf8ea77dc59817257822927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #268: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de030419345ca15c75ffffffff8074799b9e0956cc43135d16dfbe4d27d7e68deacc5e1a8304a74d2be412b078924b3bb3511bac855c05c9e5e9e44df3d61e967451cd8e18d6ed1885dd827714847f96ec4bb0ed4c36ce9808db8f714204f6d12927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #269: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "6f0e3eeaf42b28132b88fffffffff6c8665604d34acb19037e1ab78caaaac6ff2f7a5e9e5771d424f30f67fdab61e8ce4f8cd1214882adb65f7de94c31577052ac4e69808345809b44acb0b2bd889175fb75dd050c5a449ab9528f8f78daa10c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #270: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "cdb549f773b3e62b3708d1ffffffffbe48f7c0591ddcae7d2cb222d1f8017ab9ffcda40f792ce4d93e7e0f0e95e1a2147dddd7f6487621c30a03d710b330021979938b55f8a17f7ed7ba9ade8f2065a1fa77618f0b67add8d58c422c2453a49a2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #271: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2c3f26f96a3ac0051df4989bffffffff9fd64886c1dc4f9924d8fd6f0edb048481f2359c4faba6b53d3e8c8c3fcc16a948350f7ab3a588b28c17603a431e39a8cd6f6a5cc3b55ead0ff695d06c6860b509e46d99fccefb9f7f9e101857f743002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #272: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ac18f8418c55a2502cb7d53f9affffffff5c31d89fda6a6b8476397c04edf411dfc8bf520445cbb8ee1596fb073ea283ea130251a6fdffa5c3f5f2aaf75ca808048e33efce147c9dd92823640e338e68bfd7d0dc7a4905b3a7ac711e577e90e72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #273: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "4f9618f98e2d3a15b24094f72bb5ffffffffa2fd3e2893683e5a6ab8cf0ee610ad019f74c6941d20efda70b46c53db166503a0e393e932f688227688ba6a576293320eb7ca0710255346bdbb3102cdcf7964ef2e0988e712bc05efe16c1993452927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #274: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "422e82a3d56ed10a9cc21d31d37a25ffffffff67edf7c40204caae73ab0bc75aac8096842e8add68c34e78ce11dd71e4b54316bd3ebf7fffdeb7bd5a3ebc1883f5ca2f4f23d674502d4caf85d187215d36e3ce9f0ce219709f21a3aac003b7a82927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #275: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7075d245ccc3281b6e7b329ff738fbb417a5ffffffffa0842d9890b5cf95d018677b2d3a59b18a5ff939b70ea002250889ddcd7b7b9d776854b4943693fb92f76b4ba856ade7677bf30307b21f3ccda35d2f63aee81efd0bab6972cc0795db552927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #276: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3c80de54cd9226989443d593fa4fd6597e280ebeffffffffc1847eb76c217a95479e1ded14bcaed0379ba8e1b73d3115d84d31d4b7c30e1f05e1fc0d5957cfb0918f79e35b3d89487cf634a4f05b2e0c30857ca879f97c771e877027355b24432927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #277: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de21754e29b85601980bef3d697ea2770ce891a8cdffffffffc7906aa794b39b43dfccd0edb9e280d9a58f01164d55c3d711e14b12ac5cf3b64840ead512a0a31dbe33fa8ba84533cd5c4934365b3442ca1174899b78ef9a3199f495843897722927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #278: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8f65d92927cfb86a84dd59623fb531bb599e4d5f7289ffffffff2f1f2f57881c5b09ab637bd4caf0f4c7c7e4bca592fea20e9087c259d26a38bb4085f0bbff1145b7eb467b6748af618e9d80d6fdcd6aa24964e5a13f885bca8101de08eb0d752927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #279: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "6b63e9a74e092120160bea3877dace8a2cc7cd0e8426cbfffffffffafc8c3ca85e9b1c5a028070df5728c5c8af9b74e0667afa570a6cfa0114a5039ed15ee06fb1360907e2d9785ead362bb8d7bd661b6c29eeffd3c5037744edaeb9ad990c202927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #280: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "fc28259702a03845b6d75219444e8b43d094586e249c8699ffffffffe852512e0671a0a85c2b72d54a2fb0990e34538b4890050f5a5712f6d1a7a5fb8578f32edb1846bab6b7361479ab9c3285ca41291808f27fd5bd4fdac720e5854713694c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #281: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "1273b4502ea4e3bccee044ee8e8db7f774ecbcd52e8ceb571757ffffffffe20a7673f8526748446477dbbb0590a45492c5d7d69859d301abbaedb35b2095103a3dc70ddf9c6b524d886bed9e6af02e0e4dec0d417a414fed3807ef4422913d7c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #282: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "08fb565610a79baa0c566c66228d81814f8c53a15b96e602fb49ffffffffff6e7f085441070ecd2bb21285089ebb1aa6450d1a06c36d3ff39dfd657a796d12b5249712012029870a2459d18d47da9aa492a5e6cb4b2d8dafa9e4c5c54a2b9a8b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #283: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d59291cc2cf89f3087715fcb1aa4e79aa2403f748e97d7cd28ecaefeffffffff914c67fb61dd1e27c867398ea7322d5ab76df04bc5aa6683a8e0f30a5d287348fa07474031481dda4953e3ac1959ee8cea7e66ec412b38d6c96d28f6d37304ea2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #284: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000fffffffffffffffffffffffcffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e0ad99500288d466940031d72a9f5445a4d43784640855bf0a69874d2de5fe103c5011e6ef2c42dcd50d5d3d29f99ae6eba2c80c9244f4c5422f0979ff0c3ba5e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #286: r too large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254fffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254eab05fd9d0de26b9ce6f4819652d9fc69193d0aa398f0fba8013e09c58220455419235271228c786759095d12b75af0692dd4103f19f6a8c32f49435a1e9b8d45",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #287: r,s are large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd909135bdb6799286170f5ead2de4f6511453fe50914f3df2de54a36383df8dd480984f39a1ff38a86a68aa4201b6be5dfbfecf876219710b07badf6fdd4c6c5611feb97390d9826e7a06dfb41871c940d74415ed3cac2089f1445019bb55ed95",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #288: r and s^-1 have a large Hamming weight",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd27b4577ca009376f71303fd5dd227dcef5deb773ad5f5a84360644669ca249a54201b4272944201c3294f5baa9a3232b6dd687495fcc19a70a95bc602b4f7c0595c37eba9ee8171c1bb5ac6feaf753bc36f463e3aef16629572c0c0a8fb0800e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #289: r and s^-1 have a large Hamming weight",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6324d5555555550000000055555555555555553ef7a8e48d07df81a693439654210c70083539fbee44625e3acaafa2fcb41349392cef0633a1b8fabecee0c133b10e99915c1ebe7bf00df8535196770a58047ae2a402f26326bb7d41d4d7616337911e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #301: r and s^-1 are close to n",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a8555555550000000055555555555555553ef7a8e48d07df81a693439654210c70b533d4695dd5b8c5e07757e55e6e516f7e2c88fa0239e23f60e8ec07dd70f2871b134ee58cc583278456863f33c3a85d881f7d4a39850143e29d4eaf009afe47",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #304: point at infinity during verify",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a97fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a8f50d371b91bfb1d7d14e1323523bc3aa8cbf2c57f9e284de628c8b4536787b86f94ad887ac94d527247cd2e7d0c8b1291c553c9730405380b14cbb209f5fa2dd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #305: edge case for signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a97fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a968ec6e298eafe16539156ce57a14b04a7047c221bafc3a582eaeb0d857c4d94697bed1af17850117fdb39b2324f220a5698ed16c426a27335bb385ac8ca6fb30",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #306: edge case for signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c70bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502369da0364734d2e530fece94019265fefb781a0f1b08f6c8897bdf6557927c8b866d2d3c7dcd518b23d726960f069ad71a933d86ef8abbcce8b20f71e2a847002",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #307: u1 == 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c7044a5ad0ad0636d9f12bc9e0a6bdd5e1cbcb012ea7bf091fcec15b0c43202d52ed8adc00023a8edc02576e2b63e3e30621a471e2b2320620187bf067a1ac1ff3233e2b50ec09807accb36131fff95ed12a09a86b4ea9690aa32861576ba2362e1",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #308: u1 == n - 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c70555555550000000055555555555555553ef7a8e48d07df81a693439654210c703623ac973ced0a56fa6d882f03a7d5c7edca02cfc7b2401fab3690dbe75ab7858db06908e64b28613da7257e737f39793da8e713ba0643b92e9bb3252be7f8fe",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #309: u2 == 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c70aaaaaaaa00000000aaaaaaaaaaaaaaaa7def51c91a0fbf034d26872ca84218e1cf04ea77e9622523d894b93ff52dc3027b31959503b6fa3890e5e04263f922f1e8528fb7c006b3983c8b8400e57b4ed71740c2f3975438821199bedeaecab2e9",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #310: u2 == n - 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffde91e1ba60fdedb76a46bcb51dc0b8b4b7e019f0a28721885fa5d3a8196623397db7a2c8a1ab573e5929dc24077b508d7e683d49227996bda3e9f78dbeff773504f417f3bc9a88075c2e0aadd5a13311730cf7cc76a82f11a36eaf08a6c99a206",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #311: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdfdea5843ffeb73af94313ba4831b53fe24f799e525b1e8e8c87b59b95b430ad9dead11c7a5b396862f21974dc4752fadeff994efe9bbd05ab413765ea80b6e1f1de3f0640e8ac6edcf89cff53c40e265bb94078a343736df07aa0318fc7fe1ff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #312: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd03ffcabf2f1b4d2a65190db1680d62bb994e41c5251cd73b3c3dfc5e5bafc035d0bc472e0d7c81ebaed3a6ef96c18613bb1fea6f994326fbe80e00dfde67c7e9986c723ea4843d48389b946f64ad56c83ad70ff17ba85335667d1bb9fa619efd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #313: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd4dfbc401f971cd304b33dfdb17d0fed0fe4c1a88ae648e0d2847f74977534989a0a44ca947d66a2acb736008b9c08d1ab2ad03776e02640f78495d458dd51c326337fe5cf8c4604b1f1c409dc2d872d4294a4762420df43a30a2392e40426add",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #314: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbc4024761cd2ffd43dfdb17d0fed112b988977055cd3a8e54971eba9cda5ca71c9c2115290d008b45fb65fad0f602389298c25420b775019d42b62c3ce8a96b73877d25a8080dc02d987ca730f0405c2c9dbefac46f9e601cc3f06e9713973fd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #315: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd788048ed39a5ffa77bfb62fa1fda2257742bf35d128fb3459f2a0c909ee86f915eca1ef4c287dddc66b8bccf1b88e8a24c0018962f3c5e7efa83bc1a5ff6033e5e79c4cb2c245b8c45abdce8a8e4da758d92a607c32cd407ecaef22f1c934a71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #316: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd476d9131fd381bd917d0fed112bc9e0a5924b5ed5b11167edd8b23582b3cb15e5caaa030e7fdf0e4936bc7ab5a96353e0a01e4130c3f8bf22d473e317029a47adeb6adc462f7058f2a20d371e9702254e9b201642005b3ceda926b42b178bef9",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #317: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd8374253e3e21bd154448d0a8f640fe46fafa8b19ce78d538f6cc0a19662d3601c2fd20bac06e555bb8ac0ce69eb1ea20f83a1fc3501c8a66469b1a31f619b0986237050779f52b615bd7b8d76a25fc95ca2ed32525c75f27ffc87ac397e6cbaf",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #318: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd357cfd3be4d01d413c5b9ede36cba5452c11ee7fe14879e749ae6a2d897a52d63fd6a1ca7f77fb3b0bbe726c372010068426e11ea6ae78ce17bedae4bba86ced03ce5516406bf8cfaab8745eac1cd69018ad6f50b5461872ddfc56e0db3c8ff4",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #319: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd29798c5c0ee287d4a5e8e6b799fd86b8df5225298e6ffc807cd2f2bc27a0a6d89cb8e51e27a5ae3b624a60d6dc32734e4989db20e9bca3ede1edf7b086911114b4c104ab3c677e4b36d6556e8ad5f523410a19f2e277aa895fc57322b4427544",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #320: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd0b70f22c781092452dca1a5711fa3a5a1f72add1bf52c2ff7cae4820b30078dda3e52c156dcaf10502620b7955bc2b40bc78ef3d569e1223c262512d8f49602a4a2039f31c1097024ad3cc86e57321de032355463486164cf192944977df147f",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #321: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd16e1e458f021248a5b9434ae23f474b43ee55ba37ea585fef95c90416600f1baf19b78928720d5bee8e670fb90010fb15c37bf91b58a5157c3f3c059b2655e88cf701ec962fb4a11dcf273f5dc357e58468560c7cfeb942d074abd4329260509",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #322: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd2252d6856831b6cf895e4f0535eeaf0e5e5809753df848fe760ad86219016a9783a744459ecdfb01a5cf52b27a05bb7337482d242f235d7b4cb89345545c90a8c05d49337b9649813287de9ffe90355fd905df5f3c32945828121f37cc50de6e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #323: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd81ffe55f178da695b28c86d8b406b15dab1a9e39661a3ae017fbe390ac0972c3dd13c6b34c56982ddae124f039dfd23f4b19bbe88cee8e528ae51e5d6f3a21d7bfad4c2e6f263fe5eb59ca974d039fc0e4c3345692fb5320bdae4bd3b42a45ff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #324: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd7fffffffaaaaaaaaffffffffffffffffe9a2538f37b28a2c513dee40fecbb71a67e6f659cdde869a2f65f094e94e5b4dfad636bbf95192feeed01b0f3deb7460a37e0a51f258b7aeb51dfe592f5cfd5685bbe58712c8d9233c62886437c38ba0",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #325: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdb62f26b5f2a2b26f6de86d42ad8a13da3ab3cccd0459b201de009e526adf21f22eb6412505aec05c6545f029932087e490d05511e8ec1f599617bb367f9ecaaf805f51efcc4803403f9b1ae0124890f06a43fedcddb31830f6669af292895cb0",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #326: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbb1d9ac949dd748cd02bbbe749bd351cd57b38bb61403d700686aa7b4c90851e84db645868eab35e3a9fd80e056e2e855435e3a6b68d75a50a854625fe0d7f356d2589ac655edc9a11ef3e075eddda9abf92e72171570ef7bf43a2ee39338cfe",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #327: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd66755a00638cdaec1c732513ca0234ece52545dac11f816e818f725b4f60aaf291b9e47c56278662d75c0983b22ca8ea6aa5059b7a2ff7637eb2975e386ad66349aa8ff283d0f77c18d6d11dc062165fd13c3c0310679c1408302a16854ecfbd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #328: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd55a00c9fcdaebb6032513ca0234ecfffe98ebe492fdf02e48ca48e982beb3669f3ec2f13caf04d0192b47fb4c5311fb6d4dc6b0a9e802e5327f7ec5ee8e4834df97e3e468b7d0db867d6ecfe81e2b0f9531df87efdb47c1338ac321fefe5a432",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #329: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdab40193f9b5d76c064a27940469d9fffd31d7c925fbe05c919491d3057d66cd2d92b200aefcab6ac7dafd9acaf2fa10b3180235b8f46b4503e4693c670fccc885ef2f3aebf5b317475336256768f7c19efb7352d27e4cccadc85b6b8ab922c72",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #330: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdca0234ebb5fdcb13ca0234ecffffffffcb0dadbbc7f549f8a26b4408d0dc86000a88361eb92ecca2625b38e5f98bbabb96bf179b3d76fc48140a3bcd881523cde6bdf56033f84a5054035597375d90866aa2c96b86a41ccf6edebf47298ad489",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #331: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff3ea3677e082b9310572620ae19933a9e65b285598711c77298815ad3d0fb17ccd8fafe827e0c1afc5d8d80366e2b20e7f14a563a2ba50469d84375e868612569d39e2bb9f554355564646de99ac602cc6349cf8c1e236a7de7637d93",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #332: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd266666663bbbbbbbe6666666666666665b37902e023fab7c8f055d86e5cc41f4836f33bbc1dc0d3d3abbcef0d91f11e2ac4181076c9af0a22b1e4309d3edb2769ab443ff6f901e30c773867582997c2bec2b0cb8120d760236f3a95bbe881f75",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #333: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff36db6db7a492492492492492146c573f4c6dfc8d08a443e258970b0992f99fbe973ed4a299719baee4b432741237034dec8d72ba5103cb33e55feeb8033dd0e91134c734174889f3ebcf1b7a1ac05767289280ee7a794cebd6e69697",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #334: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff2aaaaaab7fffffffffffffffc815d0e60b3e596ecb1ad3a27cfd49c4d35ba58da30197d378e618ec0fa7e2e2d12cffd73ebbb2049d130bba434af09eff83986e6875e41ea432b7585a49b3a6c77cbb3c47919f8e82874c794635c1d2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #335: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd7fffffff55555555ffffffffffffffffd344a71e6f651458a27bdc81fd976e378651ce490f1b46d73f3ff475149be29136697334a519d7ddab0725c8d0793224e11c65bd8ca92dc8bc9ae82911f0b52751ce21dd9003ae60900bd825f590cc28",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #336: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd3fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192aa6d8e1b12c831a0da8795650ff95f101ed921d9e2f72b15b1cdaca9826b9cfc6def6d63e2bc5c089570394a4bc9f892d5e6c7a6a637b20469a58c106ad486bf37",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #337: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd5d8ecd64a4eeba466815ddf3a4de9a8e6abd9c5db0a01eb80343553da648428f0ae580bae933b4ef2997cbdbb0922328ca9a410f627a0f7dff24cb4d920e15428911e7f8cc365a8a88eb81421a361ccc2b99e309d8dcd9a98ba83c3949d893e3",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #338: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236f2347cab7dd76858fe0555ac3bc99048c4aacafdfb6bcbe05ea6c42c4934569bb726660235793aa9957a61e76e00c2c435109cf9a15dd624d53f4301047856b5b812fd521aafa69835a849cce6fbdeb6983b442d2444fe70e134c027fc46963838a40f2a36092e9004e92d8d940cf5638550ce672ce8b8d4e15eba5499249e9",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #339: point duplication during verification",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236f2347cab7dd76858fe0555ac3bc99048c4aacafdfb6bcbe05ea6c42c4934569bb726660235793aa9957a61e76e00c2c435109cf9a15dd624d53f4301047856b5b812fd521aafa69835a849cce6fbdeb6983b442d2444fe70e134c027fc469637c75bf0c5c9f6d17ffb16d2726bf30a9c7aaf31a8d317472b1ea145ab66db616",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #340: duplication bug",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023555555550000000055555555555555553ef7a8e48d07df81a693439654210c703333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aa9dd86d3b5f4a13e8511083b78002081c53ff467f11ebd98a51a633db76665d25045d5c8200c89f2fa10d849349226d21d8dfaed6ff8d5cb3e1b7e17474ebc18f7",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #343: comparison with point at infinity ",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978555555550000000055555555555555553ef7a8e48d07df81a693439654210c704fea55b32cb32aca0c12c4cd0abfb4e64b0f5a516e578c016591a93f5a0fbcc5d7d3fd10b2be668c547b212f6bb14c88f0fecd38a8a4b2c785ed3be62ce4b280",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #344: extreme value for k and edgecase s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978b6db6db6249249254924924924924924625bd7a09bec4ca81bcdd9f8fd6b63ccc6a771527024227792170a6f8eee735bf32b7f98af669ead299802e32d7c3107bc3b4b5e65ab887bbd343572b3e5619261fe3a073e2ffd78412f726867db589e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #345: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978cccccccc00000000cccccccccccccccc971f2ef152794b9d8fc7d568c9e8eaa7851c2bbad08e54ec7a9af99f49f03644d6ec6d59b207fec98de85a7d15b956efcee9960283045075684b410be8d0f7494b91aa2379f60727319f10ddeb0fe9d6",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #346: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc476699783333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aaaf6417c8a670584e388676949e53da7fc55911ff68318d1bf3061205acb19c48f8f2b743df34ad0f72674acb7505929784779cd9ac916c3669ead43026ab6d43f",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #347: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc4766997849249248db6db6dbb6db6db6db6db6db5a8b230d0b2b51dcd7ebf0c9fef7c185501421277be45a5eefec6c639930d636032565af420cf3373f557faa7f8a06438673d6cb6076e1cfcdc7dfe7384c8e5cac08d74501f2ae6e89cad195d0aa1371",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #348: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050237cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc4766997816a4502e2781e11ac82cbc9d1edd8c981584d13e18411e2f6e0478c34416e3bb0d935bf9ffc115a527735f729ca8a4ca23ee01a4894adf0e3415ac84e808bb343195a3762fea29ed38912bd9ea6c4fde70c3050893a4375850ce61d82eba33c5",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #349: extreme value for k",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296555555550000000055555555555555553ef7a8e48d07df81a693439654210c705e59f50708646be8a589355014308e60b668fb670196206c41e748e64e4dca215de37fee5c97bcaf7144d5b459982f52eeeafbdf03aacbafef38e213624a01de",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #350: extreme value for k and edgecase s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b6db6db6249249254924924924924924625bd7a09bec4ca81bcdd9f8fd6b63cc169fb797325843faff2f7a5b5445da9e2fd6226f7ef90ef0bfe924104b02db8e7bbb8de662c7b9b1cf9b22f7a2e582bd46d581d68878efb2b861b131d8a1d667",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #351: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296cccccccc00000000cccccccccccccccc971f2ef152794b9d8fc7d568c9e8eaa7271cd89c000143096b62d4e9e4ca885aef2f7023d18affdaf8b7b548981487540a1c6e954e32108435b55fa385b0f76481a609b9149ccb4b02b2ca47fe8e4da5",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #352: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2963333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aaa3d0bc7ed8f09d2cb7ddb46ebc1ed799ab1563a9ab84bf524587a220afe499c12e22dc3b3c103824a4f378d96adb0a408abf19ce7d68aa6244f78cb216fa3f8df",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #353: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c29649249248db6db6dbb6db6db6db6db6db5a8b230d0b2b51dcd7ebf0c9fef7c185a6c885ade1a4c566f9bb010d066974abb281797fa701288c721bcbd23663a9b72e424b690957168d193a6096fc77a2b004a9c7d467e007e1f2058458f98af316",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #354: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050236b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c29616a4502e2781e11ac82cbc9d1edd8c981584d13e18411e2f6e0478c34416e3bb8d3c2c2c3b765ba8289e6ac3812572a25bf75df62d87ab7330c3bdbad9ebfa5c4c6845442d66935b238578d43aec54f7caa1621d1af241d4632e0b780c423f5d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #355: extreme value for k",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2964fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #356: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502344a5ad0ad0636d9f12bc9e0a6bdd5e1cbcb012ea7bf091fcec15b0c43202d52e249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2964fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #357: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b01cbd1c01e58065711814b583f061e9d431cca994cea1313449bf97c840ae0a",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #358: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502344a5ad0ad0636d9f12bc9e0a6bdd5e1cbcb012ea7bf091fcec15b0c43202d52e249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b01cbd1c01e58065711814b583f061e9d431cca994cea1313449bf97c840ae0a",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #359: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855b292a619339f6e567a305c951c0dcbcc42d16e47f219f9e98e76e09d8770b34a0177e60492c5a8242f76f07bfe3661bde59ec2a17ce5bd2dab2abebdf89a62e204aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #360: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "dc1921946f4af96a2856e7be399007c9e807bdf4c5332f19f59ec9dd1bb8c7b3530bd6b0c9af2d69ba897f6b5fb59695cfbf33afe66dbadcf5b8d2a2a6538e23d85e489cb7a161fd55ededcedbf4cc0c0987e3e3f0f242cae934c72caa3f43e904aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #361: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023a8ea150cb80125d7381c4c1f1da8e9de2711f9917060406a73d7904519e51388f3ab9fa68bd47973a73b2d40480c2ba50c22c9d76ec217257288293285449b8604aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #362: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de47c9b27eb8d300dbb5f2c353e632c393262cf06340c4fa7f1b40c4cbd36f90986e65933ef2ed4ee5aada139f52b70539aaf63f00a91f29c69178490d57fb713dafedfb8da6189d372308cbf1489bbbdabf0c0217d1c0ff0f701aaa7a694b9c04aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #363: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d434e262a49eab7781e353a3565e482550dd0fd5defa013c7f29745eff3569f19b0c0a93f267fb6052fd8077be769c2b98953195d7bc10de844218305c6ba17a4f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #364: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f910fe774355c04d060f76d79fd7a772e421463489221bf0a33add0be9b1979110b500dcba1c69a8fbd43fa4f57f743ce124ca8b91a1f325f3fac6181175df557374f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #365: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91bb40bf217bed3fb3950c7d39f03d36dc8e3b2cd79693f125bfd06595ee1135e3541bf3532351ebb032710bdb6a1bf1bfc89a1e291ac692b3fa4780745bb556774f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #366: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91664eb7ee6db84a34df3c86ea31389a5405badd5ca99231ff556d3e75a233e73a59f3c752e52eca46137642490a51560ce0badc678754b8f72e51a2901426a1bd3cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #367: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f914cd0429bbabd2827009d6fcd843d4ce39c3e42e2d1631fd001985a79d1fd8b439638bf12dd682f60be7ef1d0e0d98f08b7bca77a1a2b869ae466189d2acdabe33cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #368: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91e56c6ea2d1b017091c44d8b6cb62b9f460e3ce9aed5e5fd41e8added97c56c04a308ec31f281e955be20b457e463440b4fcf2b80258078207fc1378180f89b553cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #369: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f911158a08d291500b4cabed3346d891eee57c176356a2624fb011f8fbbf3466830228a8c486a736006e082325b85290c5bc91f378b75d487dda46798c18f2855193cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #370: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b1db9289649f59410ea36b0c0fc8d6aa2687b29176939dd23e0dde56d309fa9d3e1535e4280559015b0dbd987366dcf43a6d1af5c23c7d584e1c3f48a12513363cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #371: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b7b16e762286cb96446aa8d4e6e7578b0a341a79f2dd1a220ac6f0ca4e24ed86ddc60a700a139b04661c547d07bbb0721780146df799ccf55e55234ecb8f12bc3cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #372: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d82a7c2717261187c8e00d8df963ff35d796edad36bc6e6bd1c91c670d9105b43dcabddaf8fcaa61f4603e7cbac0f3c0351ecd5988efb23f680d07debd1399292829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #373: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f915eb9c8845de68eb13d5befe719f462d77787802baff30ce96a5cba063254af782c026ae9be2e2a5e7ca0ff9bbd92fb6e44972186228ee9a62b87ddbe2ef66fb52829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #374: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9196843dd03c22abd2f3b782b170239f90f277921becc117d0404a8e4e36230c28f2be378f526f74a543f67165976de9ed9a31214eb4d7e6db19e1ede123dd991d2829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #375: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91766456dce1857c906f9996af729339464d27e9d98edc2d0e3b760297067421f6402385ecadae0d8081dccaf5d19037ec4e55376eced699e93646bfbbf19d0b41fffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #376: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91c605c4b2edeab20419e6518a11b2dbc2b97ed8b07cced0b19c34f777de7b9fd9edf0f612c5f46e03c719647bc8af1b29b2cde2eda700fb1cff5e159d47326dbafffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #377: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d48b68e6cabfe03cf6141c9ac54141f210e64485d9929ad7b732bfe3b7eb8a84feedae50c61bd00e19dc26f9b7e2265e4508c389109ad2f208f0772315b6c941fffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #378: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b7c81457d4aeb6aa65957098569f0479710ad7f6595d5874c35a93d12a5dd4c7b7961a0b652878c2d568069a432ca18a1a9199f2ca574dad4b9e3a05c0a1cdb300000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #379: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f916b01332ddb6edfa9a30a1321d5858e1ee3cf97e263e669f8de5e9652e76ff3f75939545fced457309a6a04ace2bd0f70139c8f7d86b02cb1cc58f9e69e96cd5a00000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #380: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91efdb884720eaeadc349f9fc356b6c0344101cd2fd8436b7d0e6a4fb93f106361f24bee6ad5dc05f7613975473aadf3aacba9e77de7d69b6ce48cb60d8113385d00000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #381: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9131230428405560dcb88fb5a646836aea9b23a23dd973dcbe8014c87b8b20eb070f9344d6e812ce166646747694a41b0aaf97374e19f3c5fb8bd7ae3d9bd0beffbcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #382: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91caa797da65b320ab0d5c470cda0b36b294359c7db9841d679174db34c4855743cf543a62f23e212745391aaf7505f345123d2685ee3b941d3de6d9b36242e5a0bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #383: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f917e5f0ab5d900d3d3d7867657e5d6d36519bc54084536e7d21c336ed8001859459450c07f201faec94b82dfb322e5ac676688294aad35aa72e727ff0b19b646aabcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #384: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d7d70c581ae9e3f66dc6a480bf037ae23f8a1e4a2136fe4b03aa69f0ca25b35689c460f8a5a5c2bbba962c8a3ee833a413e85658e62a59e2af41d9127cc47224bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #385: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91341c1b9ff3c83dd5e0dfa0bf68bcdf4bb7aa20c625975e5eeee34bb396266b3472b69f061b750fd5121b22b11366fad549c634e77765a017902a67099e0a4469bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #386: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9170bebe684cdcb5ca72a42f0d873879359bd1781a591809947628d313a3814f67aec03aca8f5587a4d535fa31027bbe9cc0e464b1c3577f4c2dcde6b2094798a9bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_secp256r1_sha256_test.json EcdsaVerify SHA-256 #387: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e184cd60b855d442f5b3c7b11eb6c4e0ae7525fe710fab9aa7c77a67f79e6fadd762927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1: signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e18b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #2: Legacy:ASN encoding of s misses leading 0",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e18b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #3: valid",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca60502329a3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e18b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #118: modify first byte of integer",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e98b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #120: modify last byte of integer",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e18b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b491568475b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #121: modify last byte of integer",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e1800b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b491568472927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #124: truncated integer",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023d45c5741946b2a137f59262ee6f5bc91001af27a5e1117a64733950642a3d1e8b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #133: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023d45c5740946b2a147f59262ee6f5bc90bd01ed280528b62b3aed5fc93f06f739b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #134: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023d45c5741946b2a137f59262ee6f5bc91001af27a5e1117a64733950642a3d1e8b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #137: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e18b329f47aa2bbd0a4c384ee1493b1f518ada018ef05465583885980861905228a2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #139: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e184cd60b865d442f5a3c7b11eb6c4e0ae79578ec6353a20bf783ecb4b6ea97b8252927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #143: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #177: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #178: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #179: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #180: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #181: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #187: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #188: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #189: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #190: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #191: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #197: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #198: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #199: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #200: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #201: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #207: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #208: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #209: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #210: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #211: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #217: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #218: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #219: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #220: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #221: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "70239dd877f7c944c422f44dea4ed1a52f2627416faf2f072fa50c772ed6f80764a1aab5000d0e804f3e2fc02bdee9be8ff312334e2ba16d11547c97711c898e6af015971cc30be6d1a206d4e013e0997772a2f91d73286ffd683b9bb2cf4f1b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #230: Edge case for Shamir multiplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "00000000690ed426ccf17803ebe2bd0884bcd58a1bb5e7477ead3645f356e7a916aea964a2f6506d6f78c81c91fc7e8bded7d397738448de1e19a0ec580bf266252cd762130c6667cfe8b7bc47d27d78391e8e80c578d1cd38c3ff033be928e92927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #231: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7300000000213f2a525c6035725235c2f696ad3ebb5ee47f140697ad25770d919cc98be2347d469bf476dfc26b9b733df2d26d6ef524af917c665baccb23c882093496459effe2d8d70727b82462f61d0ec1b7847929d10ea631dacb16b56c322927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #232: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ddf2000000005e0be0635b245f0b97978afd25daadeb3edb4a0161c27fe0604573b3c90ecd390028058164524dde892703dce3dea0d53fa8093999f07ab8aa432f67b0b8e20636695bb7d8bf0a651c802ed25a395387b5f4188c0c4075c886342927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #233: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "67ab1900000000784769c4ecb9e164d6642b8499588b89855be1ec355d0841a0bfab3098252847b328fadf2f89b95c851a7f0eb390763378f37e90119d5ba3ddbdd64e234e832b1067c2d058ccb44d978195ccebb65c2aaf1e2da9b8b4987e3b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #234: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a2bf09460000000076d7dbeffe125eaf02095dff252ee905e296b6350fc311cf204a9784074b246d8bf8bf04a4ceb1c1f1c9aaab168b1596d17093c5cd21d2cd51cce41670636783dc06a759c8847868a406c2506fe17975582fe648d1d88b522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #235: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3554e827c700000000e1e75e624a06b3a0a353171160858129e15c544e4f0e65ed66dc34f551ac82f63d4aa4f81fe2cb0031a91d1314f835027bca0f1ceeaa0399ca123aa09b13cd194a422e18d5fda167623c3f6e5d4d6abb8953d67c0c48c72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #236: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9b6cd3b812610000000026941a0f0bb53255ea4c9fd0cb3426e3a54b9fc6965c060b700bef665c68899d44f2356a578d126b062023ccc3c056bf0f60a237012b8d186c027832965f4fcc78a3366ca95dedbb410cbef3f26d6be5d581c11d36102927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #237: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "883ae39f50bf0100000000e7561c26fc82a52baa51c71ca877162f93c4ae01869f6adfe8d5eb5b2c24d7aa7934b6cf29c93ea76cd313c9132bb0c8e38c96831db26a9c9e40e55ee0890c944cf271756c906a33e66b5bd15e051593883b5e99022927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #238: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a1ce5d6e5ecaf28b0000000000fa7cd010540f420fb4ff7401fe9fce011d0ba6a1af03ca91677b673ad2f33615e56174a1abf6da168cebfa8868f4ba273f16b720aa73ffe48afa6435cd258b173d0c2377d69022e7d098d75caf24c8c5e06b1c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #239: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8ea5f645f373f580930000000038345397330012a8ee836c5494cdffd5ee8054fdc70602766f8eed11a6c99a71c973d5659355507b843da6e327a28c11893db93df5349688a085b137b1eacf456a9e9e0f6d15ec0078ca60a7f83f2b10d213502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #240: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "660570d323e9f75fa734000000008792d65ce93eabb7d60d8d9c1bbdcb5ef305b516a314f2fce530d6537f6a6c49966c23456f63c643cf8e0dc738f7b876e675d39ffd033c92b6d717dd536fbc5efdf1967c4bd80954479ba66b0120cd16fff22927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #241: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d0462673154cce587dde8800000000e98d35f1f45cf9c3bf46ada2de4c568c343b2cbf046eac45842ecb7984d475831582717bebb6492fd0a485c101e29ff0a84c9b7b47a98b0f82de512bc9313aaf51701099cac5f76e68c8595fc1c1d992582927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #242: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bd90640269a7822680cedfef000000000caef15a6171059ab83e7b4418d7278f30c87d35e636f540841f14af54e2f9edd79d0312cfa1ab656c3fb15bfde48dcf47c15a5a82d24b75c85a692bd6ecafeb71409ede23efd08e0db9abf6340677ed2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #243: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "33239a52d72f1311512e41222a00000000d2dcceb301c54b4beae8e284788a7338686ff0fda2cef6bc43b58cfe6647b9e2e8176d168dec3c68ff262113760f52067ec3b651f422669601662167fa8717e976e2db5e6a4cf7c2ddabb3fde9d67d2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #244: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "b8d64fbcd4a1c10f1365d4e6d95c000000007ee4a21a1cbe1dc84c2d941ffaf144a3e23bf314f2b344fc25c7f2de8b6af3e17d27f5ee844b225985ab6e2775cf2d48e223205e98041ddc87be532abed584f0411f5729500493c9cc3f4dd15e862927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #245: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "01603d3982bf77d7a3fef3183ed092000000003a227420db4088b20fe0e9d84a2ded5b7ec8e90e7bf11f967a3d95110c41b99db3b5aa8d330eb9d638781688e97d5792c53628155e1bfc46fb1a67e3088de049c328ae1f44ec69238a009808f92927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #246: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9ea6994f1e0384c8599aa02e6cf66d9c000000004d89ef50b7e9eb0cfbff7363bdae7bcb580bf335efd3bc3d31870f923eaccafcd40ec2f605976f15137d8b8ff6dfa12f19e525270b0106eecfe257499f373a4fb318994f24838122ce7ec3c72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #247: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d03215a8401bcf16693979371a01068a4700000000e2fa5bf692bc670905b18c50f9c4f0cd6940e162720957ffff513799209b78596956d21ece251c2401f1c6d7033a0a787d338e889defaaabb106b95a4355e411a59c32aa5167dfab2447262927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #248: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "307bfaaffb650c889c84bf83f0300e5dc87e000000008408fd5f64b582e3bb14f612820687604fa01906066a378d67540982e29575d019aabe90924ead5c860d3f9367702dd7dd4f75ea98afd20e328a1a99f4857b316525328230ce294b0fef2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #249: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bab5c4f4df540d7b33324d36bb0c157551527c00000000e4af574bb4d54ea6b89505e407657d6e8bc93db5da7aa6f5081f61980c1949f56b0f2f507da5782a7ac60d31904e3669738ffbeccab6c3656c08e0ed5cb92b3cfa5e7f71784f9c50212927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #250: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d4ba47f6ae28f274e4f58d8036f9c36ec2456f5b00000000c3b869197ef5e15ebbd16fbbb656b6d0d83e6a7787cd691b08735aed371732723e1c68a40404517d9d8e35dba96028b7787d91315be675877d2d097be5e8ee34560e3e7fd25c0f002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #251: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "79fd19c7235ea212f29f1fa00984342afe0f10aafd00000000801e47f8c184e12ec9760122db98fd06ea76848d35a6da442d2ceef7559a30cf57c61e92df327e7ab271da90859479701fccf86e462ee3393fb6814c27b760c4963625c0a198782927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #252: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8c291e8eeaa45adbaf9aba5c0583462d79cbeb7ac97300000000a37ea6700cda54e76b7683b6650baa6a7fc49b1c51eed9ba9dd463221f7a4f1005a89fe00c592ea076886c773eb937ec1cc8374b7915cfd11b1c1ae1166152f2f7806a31c8fd2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #253: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0eaae8641084fa979803efbfb8140732f4cdcf66c3f78a000000003c278a6b215291deaf24659ffbbce6e3c26f6021097a74abdbb69be4fb10419c0c496c946665d6fcf336d27cc7cdb982bb4e4ecef5827f84742f29f10abf83469270a03dc32927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #254: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "e02716d01fb23a5a0068399bf01bab42ef17c6d96e13846c00000000afc0f89d207a3241812d75d947419dc58efb05e8003b33fc17eb50f9d15166a88479f107cdee749f2e492b213ce80b32d0574f62f1c5d70793cf55e382d5caadf75927672927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #255: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9eb0bf583a1a6b9a194e9a16bc7dab2a9061768af89d00659a00000000fc7de16554e49f82a855204328ac94913bf01bbe84437a355a0a37c0dee3cf81aa7728aea00de2507ddaf5c94e1e126980d3df16250a2eaebc8be486effe7f22b4f9292927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #256: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "62aac98818b3b84a2c214f0d5e72ef286e1030cb53d9a82b690e00000000cd15a54c5062648339d2bff06f71c88216c26c6e19b4d80a8c602990ac82707efdfce99bbe7fcfafae3e69fd016777517aa01056317f467ad09aff09be73c9731b0d2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #257: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3760a7f37cf96218f29ae43732e513efd2b6f552ea4b6895464b9300000000c8975bd7157a8d363b309f1f444012b1a1d23096593133e71b4ca8b059cff37eaf7faa7a28b1c822baa241793f2abc930bd4c69840fe090f2aacc46786bf9196222927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #258: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0da0a1d2851d33023834f2098c0880096b4320bea836cd9cbb6ff6c8000000005694a6f84b8f875c276afd2ebcfe4d61de9ec90305afb1357b95b3e0da43885e0dffad9ffd0b757d8051dec02ebdf70d8ee2dc5c7870c0823b6ccc7c679cbaa42927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #259: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ffffffff293886d3086fd567aafd598f0fe975f735887194a764a231e82d289aa0c30e8026fdb2b4b4968a27d16a6d08f7098f1a98d21620d7454ba9790f1ba65e470453a8a399f15baf463f9deceb53acc5ca64459149688bd2760c654243392927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #260: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7bffffffff2376d1e3c03445a072e24326acdc4ce127ec2e0e8d9ca99527e7b7614ea84acf736527dd73602cd4bb4eea1dfebebd5ad8aca52aa0228cf7b99a88737cc85f5f2d2f60d1b8183f3ed490e4de14368e96a9482c2a4dd193195c902f2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #261: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a2b5ffffffffebb251b085377605a224bc80872602a6e467fd016807e97fa395bead6734ebe44b810d3fb2ea00b1732945377338febfd439a8d74dfbd0f942fa6bb18eae36616a7d3cad35919fd21a8af4bbe7a10f73b3e036a46b103ef56e2a2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #262: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "641227ffffffff6f1b96fa5f097fcf3cc1a3c256870d45a67b83d0967d4b20c0499625479e161dacd4db9d9ce64854c98d922cbf212703e9654fae182df9bad242c177cf37b8193a0131108d97819edd9439936028864ac195b64fca76d9d6932927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #263: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "958415d8ffffffffabad03e2fc662dc3ba203521177502298df56f36600e0f8b08f16b8093a8fb4d66a2c8065b541b3d31e3bfe694f6b89c50fb1aaa6ff6c9b29d6455e2d5d1779748573b611cb95d4a21f967410399b39b535ba3e5af81ca2e2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #264: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "f1d8de4858ffffffff1281093536f47fe13deb04e1fbe8fb954521b6975420f8be26231b6191658a19dd72ddb99ed8f8c579b6938d19bce8eed8dc2b338cb5f8e1d9a32ee56cffed37f0f22b2dcb57d5c943c14f79694a03b9c5e96952575c892927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #265: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0927895f2802ffffffff10782dd14a3b32dc5d47c05ef6f1876b95c81fc31def15e76880898316b16204ac920a02d58045f36a229d4aa4f812638c455abe0443e74d357d3fcb5c8c5337bd6aba4178b455ca10e226e13f9638196506a19391232927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #266: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "60907984aa7e8effffffff4f332862a10a57c3063fb5a30624cf6a0c3ac80589352ecb53f8df2c503a45f9846fc28d1d31e6307d3ddbffc1132315cc07f16dad1348dfa9c482c558e1d05c5242ca1c39436726ecd28258b1899792887dd0a3c62927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #267: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "c6ff198484939170ffffffff0af42cda50f9a5f50636ea6942d6b9b8cd6ae1e24a40801a7e606ba78a0da9882ab23c7677b8642349ed3d652c5bfa5f2a9558fb3a49b64848d682ef7f605f2832f7384bdc24ed2925825bf8ea77dc59817257822927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #268: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de030419345ca15c75ffffffff8074799b9e0956cc43135d16dfbe4d27d7e68deacc5e1a8304a74d2be412b078924b3bb3511bac855c05c9e5e9e44df3d61e967451cd8e18d6ed1885dd827714847f96ec4bb0ed4c36ce9808db8f714204f6d12927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #269: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "6f0e3eeaf42b28132b88fffffffff6c8665604d34acb19037e1ab78caaaac6ff2f7a5e9e5771d424f30f67fdab61e8ce4f8cd1214882adb65f7de94c31577052ac4e69808345809b44acb0b2bd889175fb75dd050c5a449ab9528f8f78daa10c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #270: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "cdb549f773b3e62b3708d1ffffffffbe48f7c0591ddcae7d2cb222d1f8017ab9ffcda40f792ce4d93e7e0f0e95e1a2147dddd7f6487621c30a03d710b330021979938b55f8a17f7ed7ba9ade8f2065a1fa77618f0b67add8d58c422c2453a49a2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #271: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2c3f26f96a3ac0051df4989bffffffff9fd64886c1dc4f9924d8fd6f0edb048481f2359c4faba6b53d3e8c8c3fcc16a948350f7ab3a588b28c17603a431e39a8cd6f6a5cc3b55ead0ff695d06c6860b509e46d99fccefb9f7f9e101857f743002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #272: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ac18f8418c55a2502cb7d53f9affffffff5c31d89fda6a6b8476397c04edf411dfc8bf520445cbb8ee1596fb073ea283ea130251a6fdffa5c3f5f2aaf75ca808048e33efce147c9dd92823640e338e68bfd7d0dc7a4905b3a7ac711e577e90e72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #273: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "4f9618f98e2d3a15b24094f72bb5ffffffffa2fd3e2893683e5a6ab8cf0ee610ad019f74c6941d20efda70b46c53db166503a0e393e932f688227688ba6a576293320eb7ca0710255346bdbb3102cdcf7964ef2e0988e712bc05efe16c1993452927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #274: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "422e82a3d56ed10a9cc21d31d37a25ffffffff67edf7c40204caae73ab0bc75aac8096842e8add68c34e78ce11dd71e4b54316bd3ebf7fffdeb7bd5a3ebc1883f5ca2f4f23d674502d4caf85d187215d36e3ce9f0ce219709f21a3aac003b7a82927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #275: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7075d245ccc3281b6e7b329ff738fbb417a5ffffffffa0842d9890b5cf95d018677b2d3a59b18a5ff939b70ea002250889ddcd7b7b9d776854b4943693fb92f76b4ba856ade7677bf30307b21f3ccda35d2f63aee81efd0bab6972cc0795db552927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #276: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3c80de54cd9226989443d593fa4fd6597e280ebeffffffffc1847eb76c217a95479e1ded14bcaed0379ba8e1b73d3115d84d31d4b7c30e1f05e1fc0d5957cfb0918f79e35b3d89487cf634a4f05b2e0c30857ca879f97c771e877027355b24432927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #277: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de21754e29b85601980bef3d697ea2770ce891a8cdffffffffc7906aa794b39b43dfccd0edb9e280d9a58f01164d55c3d711e14b12ac5cf3b64840ead512a0a31dbe33fa8ba84533cd5c4934365b3442ca1174899b78ef9a3199f495843897722927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #278: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8f65d92927cfb86a84dd59623fb531bb599e4d5f7289ffffffff2f1f2f57881c5b09ab637bd4caf0f4c7c7e4bca592fea20e9087c259d26a38bb4085f0bbff1145b7eb467b6748af618e9d80d6fdcd6aa24964e5a13f885bca8101de08eb0d752927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #279: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "6b63e9a74e092120160bea3877dace8a2cc7cd0e8426cbfffffffffafc8c3ca85e9b1c5a028070df5728c5c8af9b74e0667afa570a6cfa0114a5039ed15ee06fb1360907e2d9785ead362bb8d7bd661b6c29eeffd3c5037744edaeb9ad990c202927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #280: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "fc28259702a03845b6d75219444e8b43d094586e249c8699ffffffffe852512e0671a0a85c2b72d54a2fb0990e34538b4890050f5a5712f6d1a7a5fb8578f32edb1846bab6b7361479ab9c3285ca41291808f27fd5bd4fdac720e5854713694c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #281: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "1273b4502ea4e3bccee044ee8e8db7f774ecbcd52e8ceb571757ffffffffe20a7673f8526748446477dbbb0590a45492c5d7d69859d301abbaedb35b2095103a3dc70ddf9c6b524d886bed9e6af02e0e4dec0d417a414fed3807ef4422913d7c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #282: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "08fb565610a79baa0c566c66228d81814f8c53a15b96e602fb49ffffffffff6e7f085441070ecd2bb21285089ebb1aa6450d1a06c36d3ff39dfd657a796d12b5249712012029870a2459d18d47da9aa492a5e6cb4b2d8dafa9e4c5c54a2b9a8b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #283: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d59291cc2cf89f3087715fcb1aa4e79aa2403f748e97d7cd28ecaefeffffffff914c67fb61dd1e27c867398ea7322d5ab76df04bc5aa6683a8e0f30a5d287348fa07474031481dda4953e3ac1959ee8cea7e66ec412b38d6c96d28f6d37304ea2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #284: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25ffffffff00000001000000000000000000000000fffffffffffffffffffffffcffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254ed705d16f80987e2d9b1a6957d29ce22febf7d10fa515153182415c8361baaca4b1fc105ee5ce80d514ec1238beae2037a6f83625593620d460819e8682160926",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #636: r too large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254fffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e3cd8d2f81d6953b0844c09d7b560d527cd2ef67056893eadafa52c8501387d59ee41fdb4d10402ce7a0c5e3b747adfa3a490b62a6b7719068903485c0bb6dc2d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #637: r,s are large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd909135bdb6799286170f5ead2de4f6511453fe50914f3df2de54a36383df8dd48240cd81edd91cb6936133508c3915100e81f332c4545d41189b481196851378e05b06e72d4a1bff80ea5db514aa2f93ea6dd6d9c0ae27b7837dc432f9ce89d9",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #638: r and s^-1 have a large Hamming weight",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd27b4577ca009376f71303fd5dd227dcef5deb773ad5f5a84360644669ca249a5b062947356748b0fc17f1704c65aa1dca6e1bfe6779756fa616d91eaad13df2c0b38c17f3d0672e7409cfc5992a99fff12b84a4f8432293b431113f1b2fb579d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #639: r and s^-1 have a large Hamming weight",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6324d5555555550000000055555555555555553ef7a8e48d07df81a693439654210c707a736d8e326a9ca62bbe25a34ea4e3633b499a96afa7aaa3fcf3fd88f8e07edeb3e45879d8622b93e818443a686e869eeda7bf9ae46aa3eafcc48a5934864627",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #651: r and s^-1 are close to n",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a8555555550000000055555555555555553ef7a8e48d07df81a693439654210c700203736fcb198b15d8d7a0c80f66dddd15259240aa78d08aae67c467de04503434383438d5041ea9a387ee8e4d4e84b4471b160c6bcf2568b072f8f20e87a996",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #654: point at infinity during verify",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a97fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a878d844dc7f16b73b1f2a39730da5d8cd99fe2e70a18482384e37dcd2bfea02e1ed6572e01eb7a8d113d02c666c45ef22d3b9a6a6dea99aa43a8183c26e75d336",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #655: edge case for signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a97fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a9dec6c8257dde94110eacc8c09d2e5789cc5beb81a958b02b4d62da9599a7401466fae1614174be63970b83f6524421067b06dd6f4e9c56baca4e344fdd690f1d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #656: edge case for signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c70532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25a17f5b75a35ed64623ca5cbf1f91951292db0c23f0c2ea24c3d0cad0988cabc083a7a618625c228940730b4fa3ee64faecbb2fc20fdde7c58b3a3f6300424dc6",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #657: u1 == 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c70acd155416a8b77f34089464733ff7cd39c400e9c69af7beb9eac5054ed2ec72c04ba0cba291a37db13f33bf90dab628c04ec8393a0200419e9eaa1ebcc9fb5c31f3a0a0e6823a49b625ad57b12a32d4047970fc3428f0f0049ecf4265dc12f62",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #658: u1 == n - 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c70555555550000000055555555555555553ef7a8e48d07df81a693439654210c70692b6c828e0feed63d8aeaa2b7322f9ccbe8723a1ed39f229f204a434b8900efa1f6f6abcb38ea3b8fde38b98c7c271f274af56a8c5628dc3329069ae4dd5716",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #659: u2 == 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c70aaaaaaaa00000000aaaaaaaaaaaaaaaa7def51c91a0fbf034d26872ca84218e100cefd9162d13e64cb93687a9cd8f9755ebb5a3ef7632f800f84871874ccef09543ecbeaf7e8044ef721be2fb5f549e4b8480d2587404ebf7dbbef2c54bc0cb1",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #660: u2 == n - 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd710f8e3edc7c2d5a3fd23de844002bb949d9f794f6d5405f6d97c1bb03dd2bd2b975183b42551cf52f291d5c1921fd5e12f50c8c85a4beb9de03efa3f0f244862243018e6866df922dc313612020311ff21e242ce3fb15bc78c406b25ab43091",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #661: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdedffbc270f722c243069a7e5f40335a61a58525c7b4db2e7a8e269274ffe4e1bc25f1d166f3e211cdf042a26f8abf6094d48b8d17191d74ed71714927446699965d06dd6a88abfa49e8b4c5da6bb922851969adf9604b5accfb52a114e77ccdb",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #662: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffda25adcae105ed7ff4f95d2344e24ee523314c3e178525d007904b68919ba4d538fe5e88243a76e41a004236218a3c3a2d6eee398a23c3a0b008d7f0164cbc0ca98a20d1bdcf573513c7cfd9b83c63e3a82d40127c897697c86b8cb387af7f240",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #663: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd2e4348c645707dce6760d773de3f3e87346924b2f64bd3dd0297e766b5805ebb02148256b530fbc470c7b341970b38243ecee6d5a840a37beca2efb37e8dff2cc0adbea0882482a7489ca703a399864ba987eeb6ddb738af53a83573473cb30d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #664: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd348c673b07dce3920d773de3f3e87408869e916dbcf797d8f9684fb67753d1dca34db012ce6eda1e9c7375c5fcf3e54ed698e19615124273b3a621d021c76f8e777458d6f55a364c221e39e1205d5510bb4fbb7ddf08d8d8fdde13d1d6df7f14",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #665: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd6918ce760fb9c7241aee7bc7e7d0e8110d3d22db79ef2fb1f2d09f6ceea7a3b8b97af3fe78be15f2912b6271dd8a43badb6dd2a1b315b2ce7ae37b4e7778041d930d71ee1992d2466495c42102d08e81154c305307d1dcd52d0fa4c479b278e7",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #666: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd73b3c694391d8eadde3f3e874089464715ac20e4c126bbf6d864d648969f5b5a81e7198a3c3f23901cedc7a1d6eff6e9bf81108e6c35cd8559139af3135dbcbb9ef1568530291a8061b90c9f4285eefcba990d4570a4e3b7b737525b5d580034",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #667: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbb07ac7a86948c2c2989a16db1930ef1b89ce112595197656877e53c41457f28ab4d792ca121d1dba39cb9de645149c2ab573e8becc6ddff3cc9960f188ddf737f90ba23664153e93262ff73355415195858d7be1315a69456386de68285a3c8",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #668: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd27e4d82cb6c061dd9337c69bf9332ed3d198662d6f2299443f62c861187db648518412b69af43aae084476a68d59bbde51fbfa9e5be80563f587c9c2652f88ef2d3b90d25baa6bdb7b0c55e5240a3a98fbc24afed8523edec1c70503fc10f233",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #669: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffde7c5cf3aac2e88923b77850515fff6a12d13b356dfe9ec275c3dd81ae94609a4a08f14a644b9a935dffea4761ebaf592d1f66fe6cd373aa7f5d370af34f8352da54b5bc4025cf335900a914c2934ec2fec7a396d0a7affcad732a5741c7aaaf5",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #670: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc77838df91c1e953e016e10bddffea2317f9fee32bacfe553cede9e57a748f68ccf2296a6a89b62b90739d38af4ae3a20e9f45715b90044639241061e33f8f8caace0046491eeaa1c6e9a472b96d88f4af83e7ff1bb84438c7e058034412ae08",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #671: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd8ef071c02383d2a6c02dc217bbffd446730d0318b0425e2586220907f885f97f94b0fc1525bcabf82b1f34895e5819a06c02b23e04002276e165f962c86e3927be7c2ab4d0b25303204fb32a1f8292902792225e16a6d2dbfb29fbc89a9c3376",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #672: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd5668aaa0b545bbf9a044a32399ffbe69ce20074e34d7bdf5cf56282a769763965351f37e1de0c88c508527d89882d183ccdcf2efca407edb0627cadfd16de6ec44b4b57cdf960d32ebcc4c97847eed218425853b5b675eb781b766a1a1300349",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #673: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdd12d6e56882f6c0027cae91a27127728f7fddf478fb4fdc2b65f40a60b0eb952748bbafc320e6735cb64019710a269c6c2b5d147bdc831325cb2fb276ac971a69d655e9a755bc9d800ad21ee3fd4d980d93a7a49a8c5ccd37005177578f51163",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #674: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd7fffffffaaaaaaaaffffffffffffffffe9a2538f37b28a2c513dee40fecbb71a14b3bbd75c5e1c0c36535a934d4ab85112410b3b90fa97a31c33038964fd85cc112f7d837f8f9c36b460d636c965a5f818f2b50c5d00fb3f9705561dd6631883",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #675: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdb62f26b5f2a2b26f6de86d42ad8a13da3ab3cccd0459b201de009e526adf21f2d823533c04cd8edc6d6f950a8e08ade04a9bafa2f14a590356935671ae9305bf43178d1f88b6a57a96924c265f0ddb75b58312907b195acb59d7797303123775",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #676: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbb1d9ac949dd748cd02bbbe749bd351cd57b38bb61403d700686aa7b4c90851edb2b3408b3167d91030624c6328e8ce3ec108c105575c2f3d209b92e654bab69c34318139c50b0802c6e612f0fd3189d800df7c996d5d7b7c3d6be82836fa258",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #677: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd66755a00638cdaec1c732513ca0234ece52545dac11f816e818f725b4f60aaf209179ce7c59225392216453b2ac1e9d178c24837dfae26bc1dd7ab60638527425556b42e330289f3b826b2db7a86d19d45c2860a59f2be1ddcc3b691f95a9255",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #678: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd55a00c9fcdaebb6032513ca0234ecfffe98ebe492fdf02e48ca48e982beb366901959fb8deda56e5467b7e4b214ea4c2d0c2fb29d70ff19b6b1eccebd6568d7ed9dbd77a918297fd970bff01e1343f6925167db5a14d098a211c39cc3a413398",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #679: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdab40193f9b5d76c064a27940469d9fffd31d7c925fbe05c919491d3057d66cd2567f1fdc387e5350c852b4e8f8ba9d6d947e1c5dd7ccc61a5938245dd6bcab3a9960bebaf919514f9535c22eaaf0b5812857970e26662267b1f3eb1011130a11",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #680: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdca0234ebb5fdcb13ca0234ecffffffffcb0dadbbc7f549f8a26b4408d0dc86003499f974ff4ca6bbb2f51682fd5f51762f9dd6dd2855262660b36d46d3e4bec2f498fae2487807e220119152f0122476c64d4fa46ddce85c4546630f0d5c5e81",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #681: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff3ea3677e082b9310572620ae19933a9e65b285598711c77298815ad32c5c01662cf00c1929596257db13b26ecf30d0f3ec4b9f0351b0f27094473426e986a086060d086eee822ddd2fc744247a0154b57f7a69c51d9fdafa484e4ac7",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #682: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd266666663bbbbbbbe6666666666666665b37902e023fab7c8f055d86e5cc41f491d4cba813a04d86dbae94c23be6f52c15774183be7ba5b2d9f3cf010b160501900b8adfea6491019a9ac080d516025a541bf4b952b0ad7be4b1874b02fd544a",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #683: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff36db6db7a492492492492492146c573f4c6dfc8d08a443e258970b09ef7fd0a3a36386638330ecad41e1a3b302af36960831d0210c614b948e8aa124ef0d6d800e4047d6d3c1be0fdeaf11fcd8cab5ab59c730eb34116e35a8c7d098",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #684: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff2aaaaaab7fffffffffffffffc815d0e60b3e596ecb1ad3a27cfd49c4a521dab13cc9152d8ca77035a607fea06c55cc3ca5dbeb868cea92eafe93df2a7bfb9b28531996635e6a5ccaa2826a406ce1111bdb9c2e0ca36500418a2f43de",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #685: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd7fffffff55555555ffffffffffffffffd344a71e6f651458a27bdc81fd976e37474d58a4eec16e0d565f2187fe11d4e8e7a2683a12f38b4fc01d1237a81a10976e55f73bb7cdda46bdb67ef77f6fd2969df2b67920fb5945fde3a517a6ded4cd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #686: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd3fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192aa692da5cd4309d9a6e5cb525c37da8fa0879f7b57208cdabbf47d223a5b23a62140e0daa78cfdd207a7389aaed61738b17fc5fc3e6a5ed3397d2902e9125e6ab4",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #687: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd5d8ecd64a4eeba466815ddf3a4de9a8e6abd9c5db0a01eb80343553da648428f85689b3e0775c7718a90279f14a8082cfcd4d1f1679274f4e9b8805c570a0670167fcc5ca734552e09afa3640f4a034e15b9b7ca661ec7ff70d3f240ebe705b1",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #688: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256f2347cab7dd76858fe0555ac3bc99048c4aacafdfb6bcbe05ea6c42c4934569f21d907e3890916dc4fa1f4703c1e50d3f54ddf7383e44023a41de562aa18ed80158137755b901f797a90d4ca8887e023cb2ef63b2ba2c0d455edaef42cf237e2a964fc00d377a8592b8b61aafa7a4aaa7c7b9fd2b41d6e0e17bd1ba5677edcd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #689: point duplication during verification",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256f2347cab7dd76858fe0555ac3bc99048c4aacafdfb6bcbe05ea6c42c4934569f21d907e3890916dc4fa1f4703c1e50d3f54ddf7383e44023a41de562aa18ed80158137755b901f797a90d4ca8887e023cb2ef63b2ba2c0d455edaef42cf237ed569b03ef2c8857b6d4749e550585b5558384603d4be291f1e842e45a9881232",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #690: duplication bug",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c703333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aa9664ce273320d918d8bdb2e61201b4549b36b7cdc54e33b84adb6f2c10aac831e49e68831f18bda2973ac3d76bfbc8c5ee1cceed2dd862e2dc7c915c736cef1f4",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #693: comparison with point at infinity ",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978555555550000000055555555555555553ef7a8e48d07df81a693439654210c70961691a5e960d07a301dbbad4d86247ec27d7089faeb3ddd1add395efff1e0fe7254622cc371866cdf990d2c5377790e37d1f1519817f09a231bd260a9e78aeb",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #694: extreme value for k and edgecase s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978b6db6db6249249254924924924924924625bd7a09bec4ca81bcdd9f8fd6b63cc5d283e13ce8ca60da868e3b0fb33e6b4f1074793274e2928250e71e2aca63e9c214dc74fa25371fb4d9e506d418ed9a1bfd6d0c8bb6591d3e0f44505a84886ce",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #695: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978cccccccc00000000cccccccccccccccc971f2ef152794b9d8fc7d568c9e8eaa70fc351da038ae0803bd1d86514ae0462f9f8216551d9315aa9d297f792eef6a341c74eed786f2d33da35360ca7aa925e753f00d6077a1e9e5fc339d634019c73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #696: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc476699783333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aaaa1e34c8f16d138673fee55c080547c2bfd4de7550065f638322bba9430ce4b60662be9bb512663aa4d7df8ab3f3b4181c5d44a7bdf42436620b7d8a6b81ac936",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #697: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc4766997849249248db6db6dbb6db6db6db6db6db5a8b230d0b2b51dcd7ebf0c9fef7c1857e1a8a8338d7fd8cf41d322a302d2078a87a23c7186150ed7cda6e52817c1bdfd0a9135a89d21ce821e29014b2898349254d748272b2d4eb8d59ee34c615377f",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #698: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc4766997816a4502e2781e11ac82cbc9d1edd8c981584d13e18411e2f6e0478c34416e3bb5c19fe227a61abc65c61ee7a018cc9571b2c6f663ea33583f76a686f64be078b7b4a0d734940f613d52bc48673b457c2cf78492490a5cc5606c0541d17b24ddb",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #699: extreme value for k",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296555555550000000055555555555555553ef7a8e48d07df81a693439654210c70db02d1f3421d600e9d9ef9e47419dba3208eed08c2d4189a5db63abeb2739666e0ed26967b9ada9ed7ffe480827f90a0d210d5fd8ec628e31715e6b24125512a",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #700: extreme value for k and edgecase s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b6db6db6249249254924924924924924625bd7a09bec4ca81bcdd9f8fd6b63cc6222d1962655501893c29e441395b6c05711bd3ed5a0ef72cfab338b88229c4baaae079cb44a1af070362aaa520ee24cac2626423b0bf81af1c54311d8e2fd23",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #701: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296cccccccc00000000cccccccccccccccc971f2ef152794b9d8fc7d568c9e8eaa74ccfa24c67f3def7fa81bc99c70bb0419c0952ba599f4c03361da184b04cdca5db76b797f7f41d9c729a2219478a7e629728df870800be8cf6ca7a0a82153bfa",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #702: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2963333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aaaea1c72c91034036bac71402b6e9ecc4af3dbde7a99dc574061e99fefff9d84dab7dd057e75b78ac6f56e34eb048f0a9d29d5d055408c90d02bc2ea918c18cb63",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #703: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c29649249248db6db6dbb6db6db6db6db6db5a8b230d0b2b51dcd7ebf0c9fef7c185c2879a66d86cb20b820b7795da2da62b38924f7817d1cd350d936988e90e79bc5431a7268ff6931c7a759de024eff90bcb0177216db6fd1f3aaaa11fa3b6a083",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #704: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c29616a4502e2781e11ac82cbc9d1edd8c981584d13e18411e2f6e0478c34416e3bbab1c0f273f74abc2b848c75006f2ef3c54c26df27711b06558f455079aee0ba3df510f2ecef6d9a05997c776f14ad6456c179f0a13af1771e4d6c37fa48b47f2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #705: extreme value for k",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2964fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #706: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25acd155416a8b77f34089464733ff7cd39c400e9c69af7beb9eac5054ed2ec72c249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2964fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #707: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b01cbd1c01e58065711814b583f061e9d431cca994cea1313449bf97c840ae0a",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #708: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25acd155416a8b77f34089464733ff7cd39c400e9c69af7beb9eac5054ed2ec72c249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b01cbd1c01e58065711814b583f061e9d431cca994cea1313449bf97c840ae0a",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #709: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023a8ea150cb80125d7381c4c1f1da8e9de2711f9917060406a73d7904519e51388f3ab9fa68bd47973a73b2d40480c2ba50c22c9d76ec217257288293285449b8604aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1210: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e2530e782f964b2e2ff065a051bc7adc20615d8c43a1365713c88268822c253bcce5b16df652aa1ecb2dc8b46c515f9604e2e84cacfa7c6eec30428d2d3f4e08ed504aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1211: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855b292a619339f6e567a305c951c0dcbcc42d16e47f219f9e98e76e09d8770b34a0177e60492c5a8242f76f07bfe3661bde59ec2a17ce5bd2dab2abebdf89a62e204aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1212: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de47c9b27eb8d300dbb5f2c353e632c393262cf06340c4fa7f1b40c4cbd36f90986e65933ef2ed4ee5aada139f52b70539aaf63f00a91f29c69178490d57fb713dafedfb8da6189d372308cbf1489bbbdabf0c0217d1c0ff0f701aaa7a694b9c04aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1213: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d434e262a49eab7781e353a3565e482550dd0fd5defa013c7f29745eff3569f19b0c0a93f267fb6052fd8077be769c2b98953195d7bc10de844218305c6ba17a4f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1303: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f910fe774355c04d060f76d79fd7a772e421463489221bf0a33add0be9b1979110b500dcba1c69a8fbd43fa4f57f743ce124ca8b91a1f325f3fac6181175df557374f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1304: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91bb40bf217bed3fb3950c7d39f03d36dc8e3b2cd79693f125bfd06595ee1135e3541bf3532351ebb032710bdb6a1bf1bfc89a1e291ac692b3fa4780745bb556774f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1305: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91664eb7ee6db84a34df3c86ea31389a5405badd5ca99231ff556d3e75a233e73a59f3c752e52eca46137642490a51560ce0badc678754b8f72e51a2901426a1bd3cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1306: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f914cd0429bbabd2827009d6fcd843d4ce39c3e42e2d1631fd001985a79d1fd8b439638bf12dd682f60be7ef1d0e0d98f08b7bca77a1a2b869ae466189d2acdabe33cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1307: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91e56c6ea2d1b017091c44d8b6cb62b9f460e3ce9aed5e5fd41e8added97c56c04a308ec31f281e955be20b457e463440b4fcf2b80258078207fc1378180f89b553cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1308: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f911158a08d291500b4cabed3346d891eee57c176356a2624fb011f8fbbf3466830228a8c486a736006e082325b85290c5bc91f378b75d487dda46798c18f2855193cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1309: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b1db9289649f59410ea36b0c0fc8d6aa2687b29176939dd23e0dde56d309fa9d3e1535e4280559015b0dbd987366dcf43a6d1af5c23c7d584e1c3f48a12513363cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1310: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b7b16e762286cb96446aa8d4e6e7578b0a341a79f2dd1a220ac6f0ca4e24ed86ddc60a700a139b04661c547d07bbb0721780146df799ccf55e55234ecb8f12bc3cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1311: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d82a7c2717261187c8e00d8df963ff35d796edad36bc6e6bd1c91c670d9105b43dcabddaf8fcaa61f4603e7cbac0f3c0351ecd5988efb23f680d07debd1399292829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1312: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f915eb9c8845de68eb13d5befe719f462d77787802baff30ce96a5cba063254af782c026ae9be2e2a5e7ca0ff9bbd92fb6e44972186228ee9a62b87ddbe2ef66fb52829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1313: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9196843dd03c22abd2f3b782b170239f90f277921becc117d0404a8e4e36230c28f2be378f526f74a543f67165976de9ed9a31214eb4d7e6db19e1ede123dd991d2829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1314: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91766456dce1857c906f9996af729339464d27e9d98edc2d0e3b760297067421f6402385ecadae0d8081dccaf5d19037ec4e55376eced699e93646bfbbf19d0b41fffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1315: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91c605c4b2edeab20419e6518a11b2dbc2b97ed8b07cced0b19c34f777de7b9fd9edf0f612c5f46e03c719647bc8af1b29b2cde2eda700fb1cff5e159d47326dbafffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1316: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d48b68e6cabfe03cf6141c9ac54141f210e64485d9929ad7b732bfe3b7eb8a84feedae50c61bd00e19dc26f9b7e2265e4508c389109ad2f208f0772315b6c941fffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1317: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b7c81457d4aeb6aa65957098569f0479710ad7f6595d5874c35a93d12a5dd4c7b7961a0b652878c2d568069a432ca18a1a9199f2ca574dad4b9e3a05c0a1cdb300000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1318: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f916b01332ddb6edfa9a30a1321d5858e1ee3cf97e263e669f8de5e9652e76ff3f75939545fced457309a6a04ace2bd0f70139c8f7d86b02cb1cc58f9e69e96cd5a00000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1319: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91efdb884720eaeadc349f9fc356b6c0344101cd2fd8436b7d0e6a4fb93f106361f24bee6ad5dc05f7613975473aadf3aacba9e77de7d69b6ce48cb60d8113385d00000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1320: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9131230428405560dcb88fb5a646836aea9b23a23dd973dcbe8014c87b8b20eb070f9344d6e812ce166646747694a41b0aaf97374e19f3c5fb8bd7ae3d9bd0beffbcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1321: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91caa797da65b320ab0d5c470cda0b36b294359c7db9841d679174db34c4855743cf543a62f23e212745391aaf7505f345123d2685ee3b941d3de6d9b36242e5a0bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1322: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f917e5f0ab5d900d3d3d7867657e5d6d36519bc54084536e7d21c336ed8001859459450c07f201faec94b82dfb322e5ac676688294aad35aa72e727ff0b19b646aabcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1323: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d7d70c581ae9e3f66dc6a480bf037ae23f8a1e4a2136fe4b03aa69f0ca25b35689c460f8a5a5c2bbba962c8a3ee833a413e85658e62a59e2af41d9127cc47224bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1324: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91341c1b9ff3c83dd5e0dfa0bf68bcdf4bb7aa20c625975e5eeee34bb396266b3472b69f061b750fd5121b22b11366fad549c634e77765a017902a67099e0a4469bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1325: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9170bebe684cdcb5ca72a42f0d873879359bd1781a591809947628d313a3814f67aec03aca8f5587a4d535fa31027bbe9cc0e464b1c3577f4c2dcde6b2094798a9bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_test.json EcdsaVerify SHA-256 #1326: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e184cd60b855d442f5b3c7b11eb6c4e0ae7525fe710fab9aa7c77a67f79e6fadd762927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #1: signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023d45c5740946b2a147f59262ee6f5bc90bd01ed280528b62b3aed5fc93f06f739b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #3: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023d45c5741946b2a137f59262ee6f5bc91001af27a5e1117a64733950642a3d1e8b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #5: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050232ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e184cd60b865d442f5a3c7b11eb6c4e0ae79578ec6353a20bf783ecb4b6ea97b8252927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #8: Modified r or s, e.g. by adding or subtracting the order of the group",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #9: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #10: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #11: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #12: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #13: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000000ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #14: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000000ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #15: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #16: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #17: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000001ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #18: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000001ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #19: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000001ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #20: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000001ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #21: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca6050230000000000000000000000000000000000000000000000000000000000000001ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #22: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255100000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #23: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255100000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #24: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #25: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #26: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #27: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #28: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #29: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255000000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #30: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255000000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #31: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #32: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #33: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #34: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #35: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632550ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #36: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255200000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #37: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255200000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #38: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #39: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #40: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #41: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #42: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632552ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #43: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #44: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #45: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #46: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #47: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #48: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #49: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000000ffffffffffffffffffffffffffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #50: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff0000000100000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #51: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff0000000100000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000012927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #52: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325512927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #53: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #54: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6325522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #55: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff00000001000000000000000000000000ffffffffffffffffffffffff2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #56: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023ffffffff00000001000000000000000000000001000000000000000000000000ffffffff000000010000000000000000000000010000000000000000000000002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #57: Signature with special case values for r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "70239dd877f7c944c422f44dea4ed1a52f2627416faf2f072fa50c772ed6f80764a1aab5000d0e804f3e2fc02bdee9be8ff312334e2ba16d11547c97711c898e6af015971cc30be6d1a206d4e013e0997772a2f91d73286ffd683b9bb2cf4f1b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #58: Edge case for Shamir multiplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "00000000690ed426ccf17803ebe2bd0884bcd58a1bb5e7477ead3645f356e7a916aea964a2f6506d6f78c81c91fc7e8bded7d397738448de1e19a0ec580bf266252cd762130c6667cfe8b7bc47d27d78391e8e80c578d1cd38c3ff033be928e92927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #59: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7300000000213f2a525c6035725235c2f696ad3ebb5ee47f140697ad25770d919cc98be2347d469bf476dfc26b9b733df2d26d6ef524af917c665baccb23c882093496459effe2d8d70727b82462f61d0ec1b7847929d10ea631dacb16b56c322927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #60: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ddf2000000005e0be0635b245f0b97978afd25daadeb3edb4a0161c27fe0604573b3c90ecd390028058164524dde892703dce3dea0d53fa8093999f07ab8aa432f67b0b8e20636695bb7d8bf0a651c802ed25a395387b5f4188c0c4075c886342927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #61: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "67ab1900000000784769c4ecb9e164d6642b8499588b89855be1ec355d0841a0bfab3098252847b328fadf2f89b95c851a7f0eb390763378f37e90119d5ba3ddbdd64e234e832b1067c2d058ccb44d978195ccebb65c2aaf1e2da9b8b4987e3b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #62: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a2bf09460000000076d7dbeffe125eaf02095dff252ee905e296b6350fc311cf204a9784074b246d8bf8bf04a4ceb1c1f1c9aaab168b1596d17093c5cd21d2cd51cce41670636783dc06a759c8847868a406c2506fe17975582fe648d1d88b522927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #63: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3554e827c700000000e1e75e624a06b3a0a353171160858129e15c544e4f0e65ed66dc34f551ac82f63d4aa4f81fe2cb0031a91d1314f835027bca0f1ceeaa0399ca123aa09b13cd194a422e18d5fda167623c3f6e5d4d6abb8953d67c0c48c72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #64: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9b6cd3b812610000000026941a0f0bb53255ea4c9fd0cb3426e3a54b9fc6965c060b700bef665c68899d44f2356a578d126b062023ccc3c056bf0f60a237012b8d186c027832965f4fcc78a3366ca95dedbb410cbef3f26d6be5d581c11d36102927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #65: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "883ae39f50bf0100000000e7561c26fc82a52baa51c71ca877162f93c4ae01869f6adfe8d5eb5b2c24d7aa7934b6cf29c93ea76cd313c9132bb0c8e38c96831db26a9c9e40e55ee0890c944cf271756c906a33e66b5bd15e051593883b5e99022927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #66: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a1ce5d6e5ecaf28b0000000000fa7cd010540f420fb4ff7401fe9fce011d0ba6a1af03ca91677b673ad2f33615e56174a1abf6da168cebfa8868f4ba273f16b720aa73ffe48afa6435cd258b173d0c2377d69022e7d098d75caf24c8c5e06b1c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #67: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8ea5f645f373f580930000000038345397330012a8ee836c5494cdffd5ee8054fdc70602766f8eed11a6c99a71c973d5659355507b843da6e327a28c11893db93df5349688a085b137b1eacf456a9e9e0f6d15ec0078ca60a7f83f2b10d213502927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #68: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "660570d323e9f75fa734000000008792d65ce93eabb7d60d8d9c1bbdcb5ef305b516a314f2fce530d6537f6a6c49966c23456f63c643cf8e0dc738f7b876e675d39ffd033c92b6d717dd536fbc5efdf1967c4bd80954479ba66b0120cd16fff22927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #69: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d0462673154cce587dde8800000000e98d35f1f45cf9c3bf46ada2de4c568c343b2cbf046eac45842ecb7984d475831582717bebb6492fd0a485c101e29ff0a84c9b7b47a98b0f82de512bc9313aaf51701099cac5f76e68c8595fc1c1d992582927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #70: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bd90640269a7822680cedfef000000000caef15a6171059ab83e7b4418d7278f30c87d35e636f540841f14af54e2f9edd79d0312cfa1ab656c3fb15bfde48dcf47c15a5a82d24b75c85a692bd6ecafeb71409ede23efd08e0db9abf6340677ed2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #71: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "33239a52d72f1311512e41222a00000000d2dcceb301c54b4beae8e284788a7338686ff0fda2cef6bc43b58cfe6647b9e2e8176d168dec3c68ff262113760f52067ec3b651f422669601662167fa8717e976e2db5e6a4cf7c2ddabb3fde9d67d2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #72: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "b8d64fbcd4a1c10f1365d4e6d95c000000007ee4a21a1cbe1dc84c2d941ffaf144a3e23bf314f2b344fc25c7f2de8b6af3e17d27f5ee844b225985ab6e2775cf2d48e223205e98041ddc87be532abed584f0411f5729500493c9cc3f4dd15e862927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #73: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "01603d3982bf77d7a3fef3183ed092000000003a227420db4088b20fe0e9d84a2ded5b7ec8e90e7bf11f967a3d95110c41b99db3b5aa8d330eb9d638781688e97d5792c53628155e1bfc46fb1a67e3088de049c328ae1f44ec69238a009808f92927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #74: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9ea6994f1e0384c8599aa02e6cf66d9c000000004d89ef50b7e9eb0cfbff7363bdae7bcb580bf335efd3bc3d31870f923eaccafcd40ec2f605976f15137d8b8ff6dfa12f19e525270b0106eecfe257499f373a4fb318994f24838122ce7ec3c72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #75: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d03215a8401bcf16693979371a01068a4700000000e2fa5bf692bc670905b18c50f9c4f0cd6940e162720957ffff513799209b78596956d21ece251c2401f1c6d7033a0a787d338e889defaaabb106b95a4355e411a59c32aa5167dfab2447262927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #76: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "307bfaaffb650c889c84bf83f0300e5dc87e000000008408fd5f64b582e3bb14f612820687604fa01906066a378d67540982e29575d019aabe90924ead5c860d3f9367702dd7dd4f75ea98afd20e328a1a99f4857b316525328230ce294b0fef2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #77: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bab5c4f4df540d7b33324d36bb0c157551527c00000000e4af574bb4d54ea6b89505e407657d6e8bc93db5da7aa6f5081f61980c1949f56b0f2f507da5782a7ac60d31904e3669738ffbeccab6c3656c08e0ed5cb92b3cfa5e7f71784f9c50212927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #78: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d4ba47f6ae28f274e4f58d8036f9c36ec2456f5b00000000c3b869197ef5e15ebbd16fbbb656b6d0d83e6a7787cd691b08735aed371732723e1c68a40404517d9d8e35dba96028b7787d91315be675877d2d097be5e8ee34560e3e7fd25c0f002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #79: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "79fd19c7235ea212f29f1fa00984342afe0f10aafd00000000801e47f8c184e12ec9760122db98fd06ea76848d35a6da442d2ceef7559a30cf57c61e92df327e7ab271da90859479701fccf86e462ee3393fb6814c27b760c4963625c0a198782927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #80: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8c291e8eeaa45adbaf9aba5c0583462d79cbeb7ac97300000000a37ea6700cda54e76b7683b6650baa6a7fc49b1c51eed9ba9dd463221f7a4f1005a89fe00c592ea076886c773eb937ec1cc8374b7915cfd11b1c1ae1166152f2f7806a31c8fd2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #81: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0eaae8641084fa979803efbfb8140732f4cdcf66c3f78a000000003c278a6b215291deaf24659ffbbce6e3c26f6021097a74abdbb69be4fb10419c0c496c946665d6fcf336d27cc7cdb982bb4e4ecef5827f84742f29f10abf83469270a03dc32927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #82: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "e02716d01fb23a5a0068399bf01bab42ef17c6d96e13846c00000000afc0f89d207a3241812d75d947419dc58efb05e8003b33fc17eb50f9d15166a88479f107cdee749f2e492b213ce80b32d0574f62f1c5d70793cf55e382d5caadf75927672927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #83: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "9eb0bf583a1a6b9a194e9a16bc7dab2a9061768af89d00659a00000000fc7de16554e49f82a855204328ac94913bf01bbe84437a355a0a37c0dee3cf81aa7728aea00de2507ddaf5c94e1e126980d3df16250a2eaebc8be486effe7f22b4f9292927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #84: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "62aac98818b3b84a2c214f0d5e72ef286e1030cb53d9a82b690e00000000cd15a54c5062648339d2bff06f71c88216c26c6e19b4d80a8c602990ac82707efdfce99bbe7fcfafae3e69fd016777517aa01056317f467ad09aff09be73c9731b0d2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #85: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3760a7f37cf96218f29ae43732e513efd2b6f552ea4b6895464b9300000000c8975bd7157a8d363b309f1f444012b1a1d23096593133e71b4ca8b059cff37eaf7faa7a28b1c822baa241793f2abc930bd4c69840fe090f2aacc46786bf9196222927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #86: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0da0a1d2851d33023834f2098c0880096b4320bea836cd9cbb6ff6c8000000005694a6f84b8f875c276afd2ebcfe4d61de9ec90305afb1357b95b3e0da43885e0dffad9ffd0b757d8051dec02ebdf70d8ee2dc5c7870c0823b6ccc7c679cbaa42927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #87: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ffffffff293886d3086fd567aafd598f0fe975f735887194a764a231e82d289aa0c30e8026fdb2b4b4968a27d16a6d08f7098f1a98d21620d7454ba9790f1ba65e470453a8a399f15baf463f9deceb53acc5ca64459149688bd2760c654243392927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #88: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7bffffffff2376d1e3c03445a072e24326acdc4ce127ec2e0e8d9ca99527e7b7614ea84acf736527dd73602cd4bb4eea1dfebebd5ad8aca52aa0228cf7b99a88737cc85f5f2d2f60d1b8183f3ed490e4de14368e96a9482c2a4dd193195c902f2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #89: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "a2b5ffffffffebb251b085377605a224bc80872602a6e467fd016807e97fa395bead6734ebe44b810d3fb2ea00b1732945377338febfd439a8d74dfbd0f942fa6bb18eae36616a7d3cad35919fd21a8af4bbe7a10f73b3e036a46b103ef56e2a2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #90: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "641227ffffffff6f1b96fa5f097fcf3cc1a3c256870d45a67b83d0967d4b20c0499625479e161dacd4db9d9ce64854c98d922cbf212703e9654fae182df9bad242c177cf37b8193a0131108d97819edd9439936028864ac195b64fca76d9d6932927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #91: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "958415d8ffffffffabad03e2fc662dc3ba203521177502298df56f36600e0f8b08f16b8093a8fb4d66a2c8065b541b3d31e3bfe694f6b89c50fb1aaa6ff6c9b29d6455e2d5d1779748573b611cb95d4a21f967410399b39b535ba3e5af81ca2e2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #92: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "f1d8de4858ffffffff1281093536f47fe13deb04e1fbe8fb954521b6975420f8be26231b6191658a19dd72ddb99ed8f8c579b6938d19bce8eed8dc2b338cb5f8e1d9a32ee56cffed37f0f22b2dcb57d5c943c14f79694a03b9c5e96952575c892927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #93: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "0927895f2802ffffffff10782dd14a3b32dc5d47c05ef6f1876b95c81fc31def15e76880898316b16204ac920a02d58045f36a229d4aa4f812638c455abe0443e74d357d3fcb5c8c5337bd6aba4178b455ca10e226e13f9638196506a19391232927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #94: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "60907984aa7e8effffffff4f332862a10a57c3063fb5a30624cf6a0c3ac80589352ecb53f8df2c503a45f9846fc28d1d31e6307d3ddbffc1132315cc07f16dad1348dfa9c482c558e1d05c5242ca1c39436726ecd28258b1899792887dd0a3c62927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #95: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "c6ff198484939170ffffffff0af42cda50f9a5f50636ea6942d6b9b8cd6ae1e24a40801a7e606ba78a0da9882ab23c7677b8642349ed3d652c5bfa5f2a9558fb3a49b64848d682ef7f605f2832f7384bdc24ed2925825bf8ea77dc59817257822927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #96: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de030419345ca15c75ffffffff8074799b9e0956cc43135d16dfbe4d27d7e68deacc5e1a8304a74d2be412b078924b3bb3511bac855c05c9e5e9e44df3d61e967451cd8e18d6ed1885dd827714847f96ec4bb0ed4c36ce9808db8f714204f6d12927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #97: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "6f0e3eeaf42b28132b88fffffffff6c8665604d34acb19037e1ab78caaaac6ff2f7a5e9e5771d424f30f67fdab61e8ce4f8cd1214882adb65f7de94c31577052ac4e69808345809b44acb0b2bd889175fb75dd050c5a449ab9528f8f78daa10c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #98: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "cdb549f773b3e62b3708d1ffffffffbe48f7c0591ddcae7d2cb222d1f8017ab9ffcda40f792ce4d93e7e0f0e95e1a2147dddd7f6487621c30a03d710b330021979938b55f8a17f7ed7ba9ade8f2065a1fa77618f0b67add8d58c422c2453a49a2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #99: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2c3f26f96a3ac0051df4989bffffffff9fd64886c1dc4f9924d8fd6f0edb048481f2359c4faba6b53d3e8c8c3fcc16a948350f7ab3a588b28c17603a431e39a8cd6f6a5cc3b55ead0ff695d06c6860b509e46d99fccefb9f7f9e101857f743002927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #100: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "ac18f8418c55a2502cb7d53f9affffffff5c31d89fda6a6b8476397c04edf411dfc8bf520445cbb8ee1596fb073ea283ea130251a6fdffa5c3f5f2aaf75ca808048e33efce147c9dd92823640e338e68bfd7d0dc7a4905b3a7ac711e577e90e72927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #101: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "4f9618f98e2d3a15b24094f72bb5ffffffffa2fd3e2893683e5a6ab8cf0ee610ad019f74c6941d20efda70b46c53db166503a0e393e932f688227688ba6a576293320eb7ca0710255346bdbb3102cdcf7964ef2e0988e712bc05efe16c1993452927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #102: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "422e82a3d56ed10a9cc21d31d37a25ffffffff67edf7c40204caae73ab0bc75aac8096842e8add68c34e78ce11dd71e4b54316bd3ebf7fffdeb7bd5a3ebc1883f5ca2f4f23d674502d4caf85d187215d36e3ce9f0ce219709f21a3aac003b7a82927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #103: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "7075d245ccc3281b6e7b329ff738fbb417a5ffffffffa0842d9890b5cf95d018677b2d3a59b18a5ff939b70ea002250889ddcd7b7b9d776854b4943693fb92f76b4ba856ade7677bf30307b21f3ccda35d2f63aee81efd0bab6972cc0795db552927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #104: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "3c80de54cd9226989443d593fa4fd6597e280ebeffffffffc1847eb76c217a95479e1ded14bcaed0379ba8e1b73d3115d84d31d4b7c30e1f05e1fc0d5957cfb0918f79e35b3d89487cf634a4f05b2e0c30857ca879f97c771e877027355b24432927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #105: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de21754e29b85601980bef3d697ea2770ce891a8cdffffffffc7906aa794b39b43dfccd0edb9e280d9a58f01164d55c3d711e14b12ac5cf3b64840ead512a0a31dbe33fa8ba84533cd5c4934365b3442ca1174899b78ef9a3199f495843897722927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #106: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "8f65d92927cfb86a84dd59623fb531bb599e4d5f7289ffffffff2f1f2f57881c5b09ab637bd4caf0f4c7c7e4bca592fea20e9087c259d26a38bb4085f0bbff1145b7eb467b6748af618e9d80d6fdcd6aa24964e5a13f885bca8101de08eb0d752927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #107: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "6b63e9a74e092120160bea3877dace8a2cc7cd0e8426cbfffffffffafc8c3ca85e9b1c5a028070df5728c5c8af9b74e0667afa570a6cfa0114a5039ed15ee06fb1360907e2d9785ead362bb8d7bd661b6c29eeffd3c5037744edaeb9ad990c202927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #108: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "fc28259702a03845b6d75219444e8b43d094586e249c8699ffffffffe852512e0671a0a85c2b72d54a2fb0990e34538b4890050f5a5712f6d1a7a5fb8578f32edb1846bab6b7361479ab9c3285ca41291808f27fd5bd4fdac720e5854713694c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #109: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "1273b4502ea4e3bccee044ee8e8db7f774ecbcd52e8ceb571757ffffffffe20a7673f8526748446477dbbb0590a45492c5d7d69859d301abbaedb35b2095103a3dc70ddf9c6b524d886bed9e6af02e0e4dec0d417a414fed3807ef4422913d7c2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #110: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "08fb565610a79baa0c566c66228d81814f8c53a15b96e602fb49ffffffffff6e7f085441070ecd2bb21285089ebb1aa6450d1a06c36d3ff39dfd657a796d12b5249712012029870a2459d18d47da9aa492a5e6cb4b2d8dafa9e4c5c54a2b9a8b2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #111: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "d59291cc2cf89f3087715fcb1aa4e79aa2403f748e97d7cd28ecaefeffffffff914c67fb61dd1e27c867398ea7322d5ab76df04bc5aa6683a8e0f30a5d287348fa07474031481dda4953e3ac1959ee8cea7e66ec412b38d6c96d28f6d37304ea2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #112: special case hash",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25000000000000000000000000000000004319055358e8617b0c46353d039cdaabffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254ed705d16f80987e2d9b1a6957d29ce22febf7d10fa515153182415c8361baaca4b1fc105ee5ce80d514ec1238beae2037a6f83625593620d460819e8682160926",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #113: k*G has a large x-coordinate",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25ffffffff00000001000000000000000000000000fffffffffffffffffffffffcffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254ed705d16f80987e2d9b1a6957d29ce22febf7d10fa515153182415c8361baaca4b1fc105ee5ce80d514ec1238beae2037a6f83625593620d460819e8682160926",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #114: r too large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254fffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e3cd8d2f81d6953b0844c09d7b560d527cd2ef67056893eadafa52c8501387d59ee41fdb4d10402ce7a0c5e3b747adfa3a490b62a6b7719068903485c0bb6dc2d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #115: r,s are large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd909135bdb6799286170f5ead2de4f6511453fe50914f3df2de54a36383df8dd48240cd81edd91cb6936133508c3915100e81f332c4545d41189b481196851378e05b06e72d4a1bff80ea5db514aa2f93ea6dd6d9c0ae27b7837dc432f9ce89d9",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #116: r and s^-1 have a large Hamming weight",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd27b4577ca009376f71303fd5dd227dcef5deb773ad5f5a84360644669ca249a5b062947356748b0fc17f1704c65aa1dca6e1bfe6779756fa616d91eaad13df2c0b38c17f3d0672e7409cfc5992a99fff12b84a4f8432293b431113f1b2fb579d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #117: r and s^-1 have a large Hamming weight",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000014a03ef9f92eb268cafa601072489a56380fa0dc43171d7712813b3a19a1eb5e53e213e28a608ce9a2f4a17fd830c6654018a79b3e0263d91a8ba90622df6f2f0",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #118: small r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e2500000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000003091194c1cba17f34e286b4833701606a41cef26177ada8850b601ea1f859e70127242fcec708828758403ce2fe501983a7984e6209f4d6b95db9ad77767f55eb",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #120: small r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e2500000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000005103c6ecceff59e71ea8f56fee3a4b2b148e81c2bdbdd39c195812c96dcfb41a72303a193dc591be150b883d770ec51ebb4ebce8b09042c2ecb16c448d8e57bf5",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #122: small r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000063b66b829fe604638bcb2bfe8c22228be67390c20111bd2b451468927e87fb6eabc8e59c009361758b274ba2cad36b58fde485a3ed09dade76712fa9e9c4ac212",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #124: small r and s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63255600000000000000000000000000000000000000000000000000000000000000063b66b829fe604638bcb2bfe8c22228be67390c20111bd2b451468927e87fb6eabc8e59c009361758b274ba2cad36b58fde485a3ed09dade76712fa9e9c4ac212",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #126: r is larger than n",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e250000000000000000000000000000000000000000000000000000000000000005ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc75fbd84ff2f6c24e4a33cd71c09fdcbc74a6233961b874b8c8e0eb94582092cbc50c3084fa9547afda5c66335f3f937d4c79afa120486b534139d59ae82d61ead26420",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #127: s is larger than n",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e2500000000000000000000000000000000000000000000000000000000000001008f1e3c7862c58b16bb76eddbb76eddbb516af4f63f2d74d76e0d28c9bb75ea8884b959080bb30859cd53c2fb973cf14d60cdaa8ee00587889b5bc657ac588175a02ce5c1e53cb196113c78b4cb8dc7d360e5ea7850b0f6650b0c45af2c3cd7ca",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #128: small r and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25000000000000000000000000000000000000000000000000002d9b4d347952d6ef3043e7329581dbb3974497710ab11505ee1c87ff907beebadd195a0ffe6d7adf4083bd6ecbda5a77ae578e5d835fa7f74a07ebb91e0570e1ff32a563354e9925af80b09a167d9ef647df28e2d9acd0d4bc4f2deec5723818edaf9071e311f8",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #129: smallish r and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25000000000000000000000000000000000000001033e67e37b32b445580bf4eff8b748b74000000008b748b748b748b7466e769ad4a16d3dcd87129b8e91d1b4dc2569a3c9bf8c1838ca821f7ba6f000cc8679d278f3736b414a34a7c956a03770387ea85bc4f28804b4a91c9b7d65bc6434c975806795ab7d441a4e9683aeb09",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #130: 100-bit r and small s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e250000000000000000000000000000000000000000000000000000000000000100ef9f6ba4d97c09d03178fa20b4aaad83be3cf9cb824a879fec3270fc4b81ef5b4a9f7da2a6c359a16540c271774a6bf1c586357c978256f44a6496d80670968ac496e73a44563f8d56fbd7bb9e4e3ae304c86f2c508eb777b03924755beb40d4",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #131: small r and 100 bit s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e2500000000000000000000000000000000000000062522bbd3ecbe7c39e93e7c25ef9f6ba4d97c09d03178fa20b4aaad83be3cf9cb824a879fec3270fc4b81ef5b874146432b3cd2c9e26204c0a34136996067d466dde4917a8ff23a8e95ca106b709b3d50976ef8b385a813bc35f3a20710bdc6edd465e6f43ac4866703a6608c",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #132: 100-bit r and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc6324d5555555550000000055555555555555553ef7a8e48d07df81a693439654210c707a736d8e326a9ca62bbe25a34ea4e3633b499a96afa7aaa3fcf3fd88f8e07edeb3e45879d8622b93e818443a686e869eeda7bf9ae46aa3eafcc48a5934864627",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #133: r and s^-1 are close to n",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c700000000000000000000000000000000000000000000000000000000000000001e84d9b232e971a43382630f99725e423ec1ecb41e55172e9c69748a03f0d5988618b15b427ad83363bd041ff75fac98ef2ee923714e7d1dfe31753793c7588d4",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #134: s == 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c700000000000000000000000000000000000000000000000000000000000000000e84d9b232e971a43382630f99725e423ec1ecb41e55172e9c69748a03f0d5988618b15b427ad83363bd041ff75fac98ef2ee923714e7d1dfe31753793c7588d4",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #135: s == 0",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a8555555550000000055555555555555553ef7a8e48d07df81a693439654210c700203736fcb198b15d8d7a0c80f66dddd15259240aa78d08aae67c467de04503434383438d5041ea9a387ee8e4d4e84b4471b160c6bcf2568b072f8f20e87a996",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #136: point at infinity during verify",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a97fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a878d844dc7f16b73b1f2a39730da5d8cd99fe2e70a18482384e37dcd2bfea02e1ed6572e01eb7a8d113d02c666c45ef22d3b9a6a6dea99aa43a8183c26e75d336",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #137: edge case for signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a97fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192a9dec6c8257dde94110eacc8c09d2e5789cc5beb81a958b02b4d62da9599a7401466fae1614174be63970b83f6524421067b06dd6f4e9c56baca4e344fdd690f1d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #138: edge case for signature malleability",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c70532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25a17f5b75a35ed64623ca5cbf1f91951292db0c23f0c2ea24c3d0cad0988cabc083a7a618625c228940730b4fa3ee64faecbb2fc20fdde7c58b3a3f6300424dc6",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #139: u1 == 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c70acd155416a8b77f34089464733ff7cd39c400e9c69af7beb9eac5054ed2ec72c04ba0cba291a37db13f33bf90dab628c04ec8393a0200419e9eaa1ebcc9fb5c31f3a0a0e6823a49b625ad57b12a32d4047970fc3428f0f0049ecf4265dc12f62",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #140: u1 == n - 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c70555555550000000055555555555555553ef7a8e48d07df81a693439654210c70692b6c828e0feed63d8aeaa2b7322f9ccbe8723a1ed39f229f204a434b8900efa1f6f6abcb38ea3b8fde38b98c7c271f274af56a8c5628dc3329069ae4dd5716",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #141: u2 == 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c70aaaaaaaa00000000aaaaaaaaaaaaaaaa7def51c91a0fbf034d26872ca84218e100cefd9162d13e64cb93687a9cd8f9755ebb5a3ef7632f800f84871874ccef09543ecbeaf7e8044ef721be2fb5f549e4b8480d2587404ebf7dbbef2c54bc0cb1",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #142: u2 == n - 1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd710f8e3edc7c2d5a3fd23de844002bb949d9f794f6d5405f6d97c1bb03dd2bd2b975183b42551cf52f291d5c1921fd5e12f50c8c85a4beb9de03efa3f0f244862243018e6866df922dc313612020311ff21e242ce3fb15bc78c406b25ab43091",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #143: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdedffbc270f722c243069a7e5f40335a61a58525c7b4db2e7a8e269274ffe4e1bc25f1d166f3e211cdf042a26f8abf6094d48b8d17191d74ed71714927446699965d06dd6a88abfa49e8b4c5da6bb922851969adf9604b5accfb52a114e77ccdb",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #144: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffda25adcae105ed7ff4f95d2344e24ee523314c3e178525d007904b68919ba4d538fe5e88243a76e41a004236218a3c3a2d6eee398a23c3a0b008d7f0164cbc0ca98a20d1bdcf573513c7cfd9b83c63e3a82d40127c897697c86b8cb387af7f240",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #145: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd2e4348c645707dce6760d773de3f3e87346924b2f64bd3dd0297e766b5805ebb02148256b530fbc470c7b341970b38243ecee6d5a840a37beca2efb37e8dff2cc0adbea0882482a7489ca703a399864ba987eeb6ddb738af53a83573473cb30d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #146: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd348c673b07dce3920d773de3f3e87408869e916dbcf797d8f9684fb67753d1dca34db012ce6eda1e9c7375c5fcf3e54ed698e19615124273b3a621d021c76f8e777458d6f55a364c221e39e1205d5510bb4fbb7ddf08d8d8fdde13d1d6df7f14",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #147: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd6918ce760fb9c7241aee7bc7e7d0e8110d3d22db79ef2fb1f2d09f6ceea7a3b8b97af3fe78be15f2912b6271dd8a43badb6dd2a1b315b2ce7ae37b4e7778041d930d71ee1992d2466495c42102d08e81154c305307d1dcd52d0fa4c479b278e7",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #148: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd73b3c694391d8eadde3f3e874089464715ac20e4c126bbf6d864d648969f5b5a81e7198a3c3f23901cedc7a1d6eff6e9bf81108e6c35cd8559139af3135dbcbb9ef1568530291a8061b90c9f4285eefcba990d4570a4e3b7b737525b5d580034",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #149: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbb07ac7a86948c2c2989a16db1930ef1b89ce112595197656877e53c41457f28ab4d792ca121d1dba39cb9de645149c2ab573e8becc6ddff3cc9960f188ddf737f90ba23664153e93262ff73355415195858d7be1315a69456386de68285a3c8",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #150: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd27e4d82cb6c061dd9337c69bf9332ed3d198662d6f2299443f62c861187db648518412b69af43aae084476a68d59bbde51fbfa9e5be80563f587c9c2652f88ef2d3b90d25baa6bdb7b0c55e5240a3a98fbc24afed8523edec1c70503fc10f233",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #151: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffde7c5cf3aac2e88923b77850515fff6a12d13b356dfe9ec275c3dd81ae94609a4a08f14a644b9a935dffea4761ebaf592d1f66fe6cd373aa7f5d370af34f8352da54b5bc4025cf335900a914c2934ec2fec7a396d0a7affcad732a5741c7aaaf5",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #152: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc77838df91c1e953e016e10bddffea2317f9fee32bacfe553cede9e57a748f68ccf2296a6a89b62b90739d38af4ae3a20e9f45715b90044639241061e33f8f8caace0046491eeaa1c6e9a472b96d88f4af83e7ff1bb84438c7e058034412ae08",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #153: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd8ef071c02383d2a6c02dc217bbffd446730d0318b0425e2586220907f885f97f94b0fc1525bcabf82b1f34895e5819a06c02b23e04002276e165f962c86e3927be7c2ab4d0b25303204fb32a1f8292902792225e16a6d2dbfb29fbc89a9c3376",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #154: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd5668aaa0b545bbf9a044a32399ffbe69ce20074e34d7bdf5cf56282a769763965351f37e1de0c88c508527d89882d183ccdcf2efca407edb0627cadfd16de6ec44b4b57cdf960d32ebcc4c97847eed218425853b5b675eb781b766a1a1300349",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #155: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdd12d6e56882f6c0027cae91a27127728f7fddf478fb4fdc2b65f40a60b0eb952748bbafc320e6735cb64019710a269c6c2b5d147bdc831325cb2fb276ac971a69d655e9a755bc9d800ad21ee3fd4d980d93a7a49a8c5ccd37005177578f51163",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #156: edge case for u1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd7fffffffaaaaaaaaffffffffffffffffe9a2538f37b28a2c513dee40fecbb71a14b3bbd75c5e1c0c36535a934d4ab85112410b3b90fa97a31c33038964fd85cc112f7d837f8f9c36b460d636c965a5f818f2b50c5d00fb3f9705561dd6631883",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #157: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdb62f26b5f2a2b26f6de86d42ad8a13da3ab3cccd0459b201de009e526adf21f2d823533c04cd8edc6d6f950a8e08ade04a9bafa2f14a590356935671ae9305bf43178d1f88b6a57a96924c265f0ddb75b58312907b195acb59d7797303123775",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #158: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbb1d9ac949dd748cd02bbbe749bd351cd57b38bb61403d700686aa7b4c90851edb2b3408b3167d91030624c6328e8ce3ec108c105575c2f3d209b92e654bab69c34318139c50b0802c6e612f0fd3189d800df7c996d5d7b7c3d6be82836fa258",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #159: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd66755a00638cdaec1c732513ca0234ece52545dac11f816e818f725b4f60aaf209179ce7c59225392216453b2ac1e9d178c24837dfae26bc1dd7ab60638527425556b42e330289f3b826b2db7a86d19d45c2860a59f2be1ddcc3b691f95a9255",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #160: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd55a00c9fcdaebb6032513ca0234ecfffe98ebe492fdf02e48ca48e982beb366901959fb8deda56e5467b7e4b214ea4c2d0c2fb29d70ff19b6b1eccebd6568d7ed9dbd77a918297fd970bff01e1343f6925167db5a14d098a211c39cc3a413398",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #161: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdab40193f9b5d76c064a27940469d9fffd31d7c925fbe05c919491d3057d66cd2567f1fdc387e5350c852b4e8f8ba9d6d947e1c5dd7ccc61a5938245dd6bcab3a9960bebaf919514f9535c22eaaf0b5812857970e26662267b1f3eb1011130a11",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #162: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdca0234ebb5fdcb13ca0234ecffffffffcb0dadbbc7f549f8a26b4408d0dc86003499f974ff4ca6bbb2f51682fd5f51762f9dd6dd2855262660b36d46d3e4bec2f498fae2487807e220119152f0122476c64d4fa46ddce85c4546630f0d5c5e81",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #163: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff3ea3677e082b9310572620ae19933a9e65b285598711c77298815ad32c5c01662cf00c1929596257db13b26ecf30d0f3ec4b9f0351b0f27094473426e986a086060d086eee822ddd2fc744247a0154b57f7a69c51d9fdafa484e4ac7",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #164: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd266666663bbbbbbbe6666666666666665b37902e023fab7c8f055d86e5cc41f491d4cba813a04d86dbae94c23be6f52c15774183be7ba5b2d9f3cf010b160501900b8adfea6491019a9ac080d516025a541bf4b952b0ad7be4b1874b02fd544a",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #165: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff36db6db7a492492492492492146c573f4c6dfc8d08a443e258970b09ef7fd0a3a36386638330ecad41e1a3b302af36960831d0210c614b948e8aa124ef0d6d800e4047d6d3c1be0fdeaf11fcd8cab5ab59c730eb34116e35a8c7d098",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #166: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbfffffff2aaaaaab7fffffffffffffffc815d0e60b3e596ecb1ad3a27cfd49c4a521dab13cc9152d8ca77035a607fea06c55cc3ca5dbeb868cea92eafe93df2a7bfb9b28531996635e6a5ccaa2826a406ce1111bdb9c2e0ca36500418a2f43de",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #167: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd7fffffff55555555ffffffffffffffffd344a71e6f651458a27bdc81fd976e37474d58a4eec16e0d565f2187fe11d4e8e7a2683a12f38b4fc01d1237a81a10976e55f73bb7cdda46bdb67ef77f6fd2969df2b67920fb5945fde3a517a6ded4cd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #168: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd3fffffff800000007fffffffffffffffde737d56d38bcf4279dce5617e3192aa692da5cd4309d9a6e5cb525c37da8fa0879f7b57208cdabbf47d223a5b23a62140e0daa78cfdd207a7389aaed61738b17fc5fc3e6a5ed3397d2902e9125e6ab4",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #169: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd5d8ecd64a4eeba466815ddf3a4de9a8e6abd9c5db0a01eb80343553da648428f85689b3e0775c7718a90279f14a8082cfcd4d1f1679274f4e9b8805c570a0670167fcc5ca734552e09afa3640f4a034e15b9b7ca661ec7ff70d3f240ebe705b1",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #170: edge case for u2",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256f2347cab7dd76858fe0555ac3bc99048c4aacafdfb6bcbe05ea6c42c4934569f21d907e3890916dc4fa1f4703c1e50d3f54ddf7383e44023a41de562aa18ed80158137755b901f797a90d4ca8887e023cb2ef63b2ba2c0d455edaef42cf237e2a964fc00d377a8592b8b61aafa7a4aaa7c7b9fd2b41d6e0e17bd1ba5677edcd",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #171: point duplication during verification",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256f2347cab7dd76858fe0555ac3bc99048c4aacafdfb6bcbe05ea6c42c4934569f21d907e3890916dc4fa1f4703c1e50d3f54ddf7383e44023a41de562aa18ed80158137755b901f797a90d4ca8887e023cb2ef63b2ba2c0d455edaef42cf237ed569b03ef2c8857b6d4749e550585b5558384603d4be291f1e842e45a9881232",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #172: duplication bug",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e250000000000000000000000000000000000000000000000000000000000000001555555550000000055555555555555553ef7a8e48d07df81a693439654210c7038a084ffccc4ae2f8204be2abca9fb8ad4ab283b2aa50f13b6bb2347adabc69ca699799b77b1cc6dad271e88b899c12931986e958e1f5cf5653dddf7389365e2",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #173: point with x-coordinate 0",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25555555550000000055555555555555553ef7a8e48d07df81a693439654210c703333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aa9664ce273320d918d8bdb2e61201b4549b36b7cdc54e33b84adb6f2c10aac831e49e68831f18bda2973ac3d76bfbc8c5ee1cceed2dd862e2dc7c915c736cef1f4",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #175: comparison with point at infinity ",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978555555550000000055555555555555553ef7a8e48d07df81a693439654210c70961691a5e960d07a301dbbad4d86247ec27d7089faeb3ddd1add395efff1e0fe7254622cc371866cdf990d2c5377790e37d1f1519817f09a231bd260a9e78aeb",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #176: extreme value for k and edgecase s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978b6db6db6249249254924924924924924625bd7a09bec4ca81bcdd9f8fd6b63cc5d283e13ce8ca60da868e3b0fb33e6b4f1074793274e2928250e71e2aca63e9c214dc74fa25371fb4d9e506d418ed9a1bfd6d0c8bb6591d3e0f44505a84886ce",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #177: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc47669978cccccccc00000000cccccccccccccccc971f2ef152794b9d8fc7d568c9e8eaa70fc351da038ae0803bd1d86514ae0462f9f8216551d9315aa9d297f792eef6a341c74eed786f2d33da35360ca7aa925e753f00d6077a1e9e5fc339d634019c73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #178: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc476699783333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aaaa1e34c8f16d138673fee55c080547c2bfd4de7550065f638322bba9430ce4b60662be9bb512663aa4d7df8ab3f3b4181c5d44a7bdf42436620b7d8a6b81ac936",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #179: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc4766997849249248db6db6dbb6db6db6db6db6db5a8b230d0b2b51dcd7ebf0c9fef7c1857e1a8a8338d7fd8cf41d322a302d2078a87a23c7186150ed7cda6e52817c1bdfd0a9135a89d21ce821e29014b2898349254d748272b2d4eb8d59ee34c615377f",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #180: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e257cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc4766997816a4502e2781e11ac82cbc9d1edd8c981584d13e18411e2f6e0478c34416e3bb5c19fe227a61abc65c61ee7a018cc9571b2c6f663ea33583f76a686f64be078b7b4a0d734940f613d52bc48673b457c2cf78492490a5cc5606c0541d17b24ddb",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #181: extreme value for k",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296555555550000000055555555555555553ef7a8e48d07df81a693439654210c70db02d1f3421d600e9d9ef9e47419dba3208eed08c2d4189a5db63abeb2739666e0ed26967b9ada9ed7ffe480827f90a0d210d5fd8ec628e31715e6b24125512a",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #182: extreme value for k and edgecase s",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b6db6db6249249254924924924924924625bd7a09bec4ca81bcdd9f8fd6b63cc6222d1962655501893c29e441395b6c05711bd3ed5a0ef72cfab338b88229c4baaae079cb44a1af070362aaa520ee24cac2626423b0bf81af1c54311d8e2fd23",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #183: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296cccccccc00000000cccccccccccccccc971f2ef152794b9d8fc7d568c9e8eaa74ccfa24c67f3def7fa81bc99c70bb0419c0952ba599f4c03361da184b04cdca5db76b797f7f41d9c729a2219478a7e629728df870800be8cf6ca7a0a82153bfa",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #184: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2963333333300000000333333333333333325c7cbbc549e52e763f1f55a327a3aaaea1c72c91034036bac71402b6e9ecc4af3dbde7a99dc574061e99fefff9d84dab7dd057e75b78ac6f56e34eb048f0a9d29d5d055408c90d02bc2ea918c18cb63",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #185: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c29649249248db6db6dbb6db6db6db6db6db5a8b230d0b2b51dcd7ebf0c9fef7c185c2879a66d86cb20b820b7795da2da62b38924f7817d1cd350d936988e90e79bc5431a7268ff6931c7a759de024eff90bcb0177216db6fd1f3aaaa11fa3b6a083",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #186: extreme value for k and s^-1",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e256b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c29616a4502e2781e11ac82cbc9d1edd8c981584d13e18411e2f6e0478c34416e3bbab1c0f273f74abc2b848c75006f2ef3c54c26df27711b06558f455079aee0ba3df510f2ecef6d9a05997c776f14ad6456c179f0a13af1771e4d6c37fa48b47f2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #187: extreme value for k",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2964fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #188: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25acd155416a8b77f34089464733ff7cd39c400e9c69af7beb9eac5054ed2ec72c249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2964fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #189: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b01cbd1c01e58065711814b583f061e9d431cca994cea1313449bf97c840ae0a",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #190: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e25acd155416a8b77f34089464733ff7cd39c400e9c69af7beb9eac5054ed2ec72c249249246db6db6ddb6db6db6db6db6dad4591868595a8ee6bf5f864ff7be0c26b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296b01cbd1c01e58065711814b583f061e9d431cca994cea1313449bf97c840ae0a",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #191: testing point duplication",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "bb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023a8ea150cb80125d7381c4c1f1da8e9de2711f9917060406a73d7904519e51388f3ab9fa68bd47973a73b2d40480c2ba50c22c9d76ec217257288293285449b8604aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #269: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "532eaabd9574880dbf76b9b8cc00832c20a6ec113d682299550d7a6e0f345e2530e782f964b2e2ff065a051bc7adc20615d8c43a1365713c88268822c253bcce5b16df652aa1ecb2dc8b46c515f9604e2e84cacfa7c6eec30428d2d3f4e08ed504aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #270: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855b292a619339f6e567a305c951c0dcbcc42d16e47f219f9e98e76e09d8770b34a0177e60492c5a8242f76f07bfe3661bde59ec2a17ce5bd2dab2abebdf89a62e204aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #271: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "de47c9b27eb8d300dbb5f2c353e632c393262cf06340c4fa7f1b40c4cbd36f90986e65933ef2ed4ee5aada139f52b70539aaf63f00a91f29c69178490d57fb713dafedfb8da6189d372308cbf1489bbbdabf0c0217d1c0ff0f701aaa7a694b9c04aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad587d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #272: pseudorandom signature",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d434e262a49eab7781e353a3565e482550dd0fd5defa013c7f29745eff3569f19b0c0a93f267fb6052fd8077be769c2b98953195d7bc10de844218305c6ba17a4f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #288: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f910fe774355c04d060f76d79fd7a772e421463489221bf0a33add0be9b1979110b500dcba1c69a8fbd43fa4f57f743ce124ca8b91a1f325f3fac6181175df557374f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #289: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91bb40bf217bed3fb3950c7d39f03d36dc8e3b2cd79693f125bfd06595ee1135e3541bf3532351ebb032710bdb6a1bf1bfc89a1e291ac692b3fa4780745bb556774f337ccfd67726a805e4f1600ae2849df3807eca117380239fbd816900000000ed9dea124cc8c396416411e988c30f427eb504af43a3146cd5df7ea60666d685",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #290: x-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91664eb7ee6db84a34df3c86ea31389a5405badd5ca99231ff556d3e75a233e73a59f3c752e52eca46137642490a51560ce0badc678754b8f72e51a2901426a1bd3cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #291: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f914cd0429bbabd2827009d6fcd843d4ce39c3e42e2d1631fd001985a79d1fd8b439638bf12dd682f60be7ef1d0e0d98f08b7bca77a1a2b869ae466189d2acdabe33cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #292: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91e56c6ea2d1b017091c44d8b6cb62b9f460e3ce9aed5e5fd41e8added97c56c04a308ec31f281e955be20b457e463440b4fcf2b80258078207fc1378180f89b553cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f49726500493584fa174d791c72bf2ce3880a8960dd2a7c7a1338a82f85a9e59cdbde80000000",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #293: y-coordinate of the public key has many trailing 0's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f911158a08d291500b4cabed3346d891eee57c176356a2624fb011f8fbbf3466830228a8c486a736006e082325b85290c5bc91f378b75d487dda46798c18f2855193cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #294: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b1db9289649f59410ea36b0c0fc8d6aa2687b29176939dd23e0dde56d309fa9d3e1535e4280559015b0dbd987366dcf43a6d1af5c23c7d584e1c3f48a12513363cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #295: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b7b16e762286cb96446aa8d4e6e7578b0a341a79f2dd1a220ac6f0ca4e24ed86ddc60a700a139b04661c547d07bbb0721780146df799ccf55e55234ecb8f12bc3cf03d614d8939cfd499a07873fac281618f06b8ff87e8015c3f4972650049357b05e8b186e38d41d31c77f5769f22d58385ecc857d07a561a6324217fffffff",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #296: y-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d82a7c2717261187c8e00d8df963ff35d796edad36bc6e6bd1c91c670d9105b43dcabddaf8fcaa61f4603e7cbac0f3c0351ecd5988efb23f680d07debd1399292829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #297: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f915eb9c8845de68eb13d5befe719f462d77787802baff30ce96a5cba063254af782c026ae9be2e2a5e7ca0ff9bbd92fb6e44972186228ee9a62b87ddbe2ef66fb52829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #298: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9196843dd03c22abd2f3b782b170239f90f277921becc117d0404a8e4e36230c28f2be378f526f74a543f67165976de9ed9a31214eb4d7e6db19e1ede123dd991d2829c31faa2e400e344ed94bca3fcd0545956ebcfe8ad0f6dfa5ff8effffffffa01aafaf000e52585855afa7676ade284113099052df57e7eb3bd37ebeb9222e",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #299: x-coordinate of the public key has many trailing 1's",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91766456dce1857c906f9996af729339464d27e9d98edc2d0e3b760297067421f6402385ecadae0d8081dccaf5d19037ec4e55376eced699e93646bfbbf19d0b41fffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #300: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91c605c4b2edeab20419e6518a11b2dbc2b97ed8b07cced0b19c34f777de7b9fd9edf0f612c5f46e03c719647bc8af1b29b2cde2eda700fb1cff5e159d47326dbafffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #301: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d48b68e6cabfe03cf6141c9ac54141f210e64485d9929ad7b732bfe3b7eb8a84feedae50c61bd00e19dc26f9b7e2265e4508c389109ad2f208f0772315b6c941fffffff948081e6a0458dd8f9e738f2665ff9059ad6aac0708318c4ca9a7a4f55a8abcba2dda8474311ee54149b973cae0c0fb89557ad0bf78e6529a1663bd73",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #302: x-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91b7c81457d4aeb6aa65957098569f0479710ad7f6595d5874c35a93d12a5dd4c7b7961a0b652878c2d568069a432ca18a1a9199f2ca574dad4b9e3a05c0a1cdb300000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #303: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f916b01332ddb6edfa9a30a1321d5858e1ee3cf97e263e669f8de5e9652e76ff3f75939545fced457309a6a04ace2bd0f70139c8f7d86b02cb1cc58f9e69e96cd5a00000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #304: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91efdb884720eaeadc349f9fc356b6c0344101cd2fd8436b7d0e6a4fb93f106361f24bee6ad5dc05f7613975473aadf3aacba9e77de7d69b6ce48cb60d8113385d00000003fa15f963949d5f03a6f5c7f86f9e0015eeb23aebbff1173937ba748e1099872070e8e87c555fa13659cca5d7fadcfcb0023ea889548ca48af2ba7e71",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #305: x-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9131230428405560dcb88fb5a646836aea9b23a23dd973dcbe8014c87b8b20eb070f9344d6e812ce166646747694a41b0aaf97374e19f3c5fb8bd7ae3d9bd0beffbcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #306: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91caa797da65b320ab0d5c470cda0b36b294359c7db9841d679174db34c4855743cf543a62f23e212745391aaf7505f345123d2685ee3b941d3de6d9b36242e5a0bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #307: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f917e5f0ab5d900d3d3d7867657e5d6d36519bc54084536e7d21c336ed8001859459450c07f201faec94b82dfb322e5ac676688294aad35aa72e727ff0b19b646aabcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015000000001352bb4a0fa2ea4cceb9ab63dd684ade5a1127bcf300a698a7193bc2",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #308: y-coordinate of the public key is small",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91d7d70c581ae9e3f66dc6a480bf037ae23f8a1e4a2136fe4b03aa69f0ca25b35689c460f8a5a5c2bbba962c8a3ee833a413e85658e62a59e2af41d9127cc47224bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #309: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f91341c1b9ff3c83dd5e0dfa0bf68bcdf4bb7aa20c625975e5eeee34bb396266b3472b69f061b750fd5121b22b11366fad549c634e77765a017902a67099e0a4469bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #310: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9170bebe684cdcb5ca72a42f0d873879359bd1781a591809947628d313a3814f67aec03aca8f5587a4d535fa31027bbe9cc0e464b1c3577f4c2dcde6b2094798a9bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af015fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "0000000000000000000000000000000000000000000000000000000000000001",
+ "Gas": 3450,
+ "Name": "wycheproof/ecdsa_webcrypto_test.json EcdsaP1363Verify SHA-256 #311: y-coordinate of the public key is large",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9170bebe684cdcb5ca72a42f0d873879359bd1781a591809947628d313a3814f67aec03aca8f5587a4d535fa31027bbe9cc0e464b1c3577f4c2dcde6b2094798a90000000000000000000000000000000000000000000000000000000000000000fffffffeecad44b6f05d15b33146549c2297b522a5eed8430cff596758e6c43d",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "invalid public key x param errors",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9170bebe684cdcb5ca72a42f0d873879359bd1781a591809947628d313a3814f67aec03aca8f5587a4d535fa31027bbe9cc0e464b1c3577f4c2dcde6b2094798a9bcbb2914c79f045eaa6ecbbc612816b3be5d2d6796707d8125e9f851c18af0150000000000000000000000000000000000000000000000000000000000000000",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "invalid public key y param errors",
+ "NoBenchmark": false
+ },
+ {
+ "Input": "2f77668a9dfbf8d5848b9eeb4a7145ca94c6ed9236e4a773f6dcafa5132b2f9170bebe684cdcb5ca72a42f0d873879359bd1781a591809947628d313a3814f67aec03aca8f5587a4d535fa31027bbe9cc0e464b1c3577f4c2dcde6b2094798a900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "Expected": "",
+ "Gas": 3450,
+ "Name": "reference point errors",
+ "NoBenchmark": false
+ }
+]
\ No newline at end of file
diff --git go-ethereum/eth/downloader/userDepositData/10.105235063-114696812.gob op-geth/eth/downloader/userDepositData/10.105235063-114696812.gob
new file mode 100644
index 0000000000000000000000000000000000000000..f26643825f272cf945fc71c953265bac6336f40a
Binary files /dev/null and op-geth/eth/downloader/userDepositData/10.105235063-114696812.gob differ
diff --git go-ethereum/eth/downloader/userDepositData/291.0-4192087.gob op-geth/eth/downloader/userDepositData/291.0-4192087.gob
new file mode 100644
index 0000000000000000000000000000000000000000..0a94e024c6638124ac5af95ef101ff7209516331
Binary files /dev/null and op-geth/eth/downloader/userDepositData/291.0-4192087.gob differ
diff --git go-ethereum/eth/downloader/userDepositData/34443.0-2412409.gob op-geth/eth/downloader/userDepositData/34443.0-2412409.gob
new file mode 100644
index 0000000000000000000000000000000000000000..750e6669594db72e1ce3d5d779651a56e3166cb2
Binary files /dev/null and op-geth/eth/downloader/userDepositData/34443.0-2412409.gob differ
diff --git go-ethereum/eth/downloader/userDepositData/420.6825766-17276566.gob op-geth/eth/downloader/userDepositData/420.6825766-17276566.gob
new file mode 100644
index 0000000000000000000000000000000000000000..d17871da6e0a732ad24b8186136d3e18d6a53f91
Binary files /dev/null and op-geth/eth/downloader/userDepositData/420.6825766-17276566.gob differ
diff --git go-ethereum/eth/downloader/userDepositData/7777777.0-9149281.gob op-geth/eth/downloader/userDepositData/7777777.0-9149281.gob
new file mode 100644
index 0000000000000000000000000000000000000000..ee63497b9c874cffc6435d680be8dc67958456c9
Binary files /dev/null and op-geth/eth/downloader/userDepositData/7777777.0-9149281.gob differ
diff --git go-ethereum/eth/downloader/userDepositData/8453.0-9101527.gob op-geth/eth/downloader/userDepositData/8453.0-9101527.gob
new file mode 100644
index 0000000000000000000000000000000000000000..88f825e01ad52bbb543527b50d88ee5640728a2d
Binary files /dev/null and op-geth/eth/downloader/userDepositData/8453.0-9101527.gob differ
diff --git go-ethereum/eth/tracers/internal/tracetest/testdata/call_tracer/failed_deposit.json op-geth/eth/tracers/internal/tracetest/testdata/call_tracer/failed_deposit.json
new file mode 100644
index 0000000000000000000000000000000000000000..2c43cdae0f732a4faae29e19cc8df11741d198fa
--- /dev/null
+++ op-geth/eth/tracers/internal/tracetest/testdata/call_tracer/failed_deposit.json
@@ -0,0 +1,47 @@
+{
+ "context": {
+ "difficulty": "3699098917",
+ "gasLimit": "5258985",
+ "miner": "0xd049bfd667cb46aa3ef5df0da3e57db3be39e511",
+ "number": "2294631",
+ "timestamp": "1513675366"
+ },
+ "genesis": {
+ "alloc": {},
+ "config": {
+ "chainId": 3,
+ "daoForkSupport": true,
+ "eip150Hash": "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d",
+ "ethash": {},
+ "eip150Block": 0,
+ "eip155Block": 0,
+ "eip158Block": 0,
+ "byzantiumBlock": 0,
+ "constantinopleBlock": 0,
+ "petersburgBlock": 0,
+ "istanbulBlock": 0,
+ "berlinBlock": 0,
+ "londonBlock": 0
+ },
+ "difficulty": "3699098917",
+ "extraData": "0x4554482e45544846414e532e4f52472d4641313738394444",
+ "gasLimit": "5263953",
+ "hash": "0x03a0f62a8106793dafcfae7b75fd2654322062d585a19cea568314d7205790dc",
+ "miner": "0xbbf5029fd710d227630c8b7d338051b8e76d50b3",
+ "mixHash": "0x15482cc64b7c00a947f5bf015dfc010db1a6a668c74df61974d6a7848c174408",
+ "nonce": "0xd1bdb150f6fd170e",
+ "number": "2294630",
+ "stateRoot": "0x1ab1a534e84cc787cda1db21e0d5920ab06017948075b759166cfea7274657a1",
+ "timestamp": "1513675347",
+ "totalDifficulty": "7160543502214733"
+ },
+ "input": "0x7ef85aa0b4f9f798a5fe956d1b79c3eff355febf9e1039a7440948845536982cb62aa03194bc339e628e6fe32c39e84392d087567b2743ea3594bc339e628e6fe32c39e84392d087567b2743ea3580871aa535d3d0c00083030d408000",
+ "result": {
+ "from":"0x0000000000000000000000000000000000000000",
+ "gas":"0x0",
+ "gasUsed":"0x30d40",
+ "input":"0x",
+ "error": "failed deposit transaction",
+ "type":"STOP"
+ }
+}
diff --git go-ethereum/eth/tracers/internal/tracetest/testdata/call_tracer_flat/failed_deposit.json op-geth/eth/tracers/internal/tracetest/testdata/call_tracer_flat/failed_deposit.json
new file mode 100644
index 0000000000000000000000000000000000000000..540cd53579b1f58a9f72da481d2f86a8572ee430
--- /dev/null
+++ op-geth/eth/tracers/internal/tracetest/testdata/call_tracer_flat/failed_deposit.json
@@ -0,0 +1,59 @@
+{
+ "context": {
+ "difficulty": "3699098917",
+ "gasLimit": "5258985",
+ "miner": "0xd049bfd667cb46aa3ef5df0da3e57db3be39e511",
+ "number": "2294631",
+ "timestamp": "1513675366"
+ },
+ "genesis": {
+ "alloc": {},
+ "config": {
+ "chainId": 3,
+ "daoForkSupport": true,
+ "eip150Hash": "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d",
+ "ethash": {},
+ "eip150Block": 0,
+ "eip155Block": 0,
+ "eip158Block": 0,
+ "byzantiumBlock": 0,
+ "constantinopleBlock": 0,
+ "petersburgBlock": 0,
+ "istanbulBlock": 0,
+ "berlinBlock": 0,
+ "londonBlock": 0
+ },
+ "difficulty": "3699098917",
+ "extraData": "0x4554482e45544846414e532e4f52472d4641313738394444",
+ "gasLimit": "5263953",
+ "hash": "0x03a0f62a8106793dafcfae7b75fd2654322062d585a19cea568314d7205790dc",
+ "miner": "0xbbf5029fd710d227630c8b7d338051b8e76d50b3",
+ "mixHash": "0x15482cc64b7c00a947f5bf015dfc010db1a6a668c74df61974d6a7848c174408",
+ "nonce": "0xd1bdb150f6fd170e",
+ "number": "2294630",
+ "stateRoot": "0x1ab1a534e84cc787cda1db21e0d5920ab06017948075b759166cfea7274657a1",
+ "timestamp": "1513675347",
+ "totalDifficulty": "7160543502214733"
+ },
+ "input": "0x7ef85aa0b4f9f798a5fe956d1b79c3eff355febf9e1039a7440948845536982cb62aa03194bc339e628e6fe32c39e84392d087567b2743ea3594bc339e628e6fe32c39e84392d087567b2743ea3580871aa535d3d0c00083030d408000",
+ "result": [
+ {
+ "action": {
+ "callType": "stop",
+ "from": "0x0000000000000000000000000000000000000000",
+ "gas": "0x0",
+ "input": "0x",
+ "value": "0x0"
+ },
+ "blockNumber": 0,
+ "error": "failed deposit transaction",
+ "result": {
+ "gasUsed": "0x0",
+ "output": "0x"
+ },
+ "subtraces": 0,
+ "traceAddress": [],
+ "type": "call"
+ }
+ ]
+}
diff --git go-ethereum/fork.yaml op-geth/fork.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..62c804a56331d8753432dd5a9f399b5f50aaa524
--- /dev/null
+++ op-geth/fork.yaml
@@ -0,0 +1,278 @@
+title: "op-geth - go-ethereum fork diff overview"
+footer: |
+ Fork-diff overview of [`op-geth`](https://github.com/ethereum-optimism/op-geth), a fork of [`go-ethereum`](https://github.com/tenderly/op-geth).
+ and execution-engine of the [OP-stack](https://github.com/ethereum-optimism/optimism).
+base:
+ name: go-ethereum
+ url: https://github.com/tenderly/op-geth
+ hash: c5ba367eb6232e3eddd7d6226bfd374449c63164 # v1.13.15
+fork:
+ name: op-geth
+ url: https://github.com/ethereum-optimism/op-geth
+ ref: refs/heads/optimism
+def:
+ title: "op-geth"
+ description: |
+ This is an overview of the changes in [`op-geth`](https://github.com/ethereum-optimism/op-geth),
+ a fork of [`go-ethereum`](https://github.com/tenderly/op-geth), part of the OP-stack.
+
+ The OP-stack architecture is modular, following the Consensus/Execution split of post-Merge Ethereum L1:
+
+ - [`op-node`](https://github.com/ethereum-optimism/optimism/tree/develop/op-node) implements most rollup-specific functionality as Consensus-Layer, similar to a L1 beacon-node.
+ - [`op-geth`](https://github.com/ethereum-optimism/op-geth) implements the Execution-Layer, with **minimal changes** for a secure Ethereum-equivalent application environment.
+
+ Related [op-stack specifications](https://github.com/ethereum-optimism/optimism/tree/develop/specs):
+
+ - [L2 Execution Engine spec](https://github.com/ethereum-optimism/optimism/blob/develop/specs/exec-engine.md)
+ - [Deposit Transaction spec](https://github.com/ethereum-optimism/optimism/blob/develop/specs/deposits.md)
+ sub:
+ - title: "Core modifications"
+ sub:
+ - title: "State-transition modifications"
+ description: ""
+ sub:
+ - title: "Deposit Transaction type"
+ description: |
+ The Bedrock upgrade introduces a `Deposit` transaction-type (`0x7E`) to enable both users and the
+ rollup system itself to change the L2 state based on L1 events and system rules as
+ [specified](https://github.com/ethereum-optimism/optimism/blob/develop/specs/deposits.md).
+ globs:
+ - "core/types/deposit_tx.go"
+ - "core/types/transaction_marshalling.go"
+ - "core/types/transaction_signing.go"
+ - title: "Transaction properties"
+ description: |
+ The `Transaction` type now exposes the deposit-transaction and L1-cost properties required for the rollup.
+ globs:
+ - "core/types/transaction.go"
+ - "core/types/tx_access_list.go"
+ - "core/types/tx_dynamic_fee.go"
+ - "core/types/tx_legacy.go"
+ - "core/types/tx_blob.go"
+ - title: "L1 cost computation"
+ description: |
+ Transactions must pay an additional L1 cost based on the amount of rollup-data-gas they consume,
+ estimated based on gas-price-oracle information and encoded tx size."
+ globs:
+ - "core/vm/evm.go"
+ - "core/evm.go"
+ - "core/types/rollup_cost.go"
+ - "core/state_processor.go"
+ - "core/state_prefetcher.go"
+ - title: Transaction processing
+ description: |
+ Deposit transactions have special processing rules: gas is pre-paid on L1,
+ and deposits with EVM-failure are included with rolled back changes (except mint).
+ For regular transactions, at the end of the transition, the 1559 burn and L1 cost are routed to vaults.
+ globs:
+ - "core/state_transition.go"
+ - title: "Core Error definitions"
+ globs:
+ - "core/error.go"
+ - title: "Gaslimit"
+ description: |
+ The gaslimit is free to be set by the Engine API caller, instead of enforcing adjustments of the
+ gaslimit in increments of 1/1024 of the previous gaslimit.
+ The gaslimit is changed (and limited) through the `SystemConfig` contract.
+ globs:
+ - "consensus/misc/eip1559/eip1559.go"
+ - title: "Consensus tweaks"
+ description: |
+ The Engine API is activated at the Merge transition, with a Total Terminal Difficulty (TTD).
+ The rollup starts post-merge, and thus sets the TTD to 0.
+ The TTD is always "reached" starting at the bedrock block.
+ globs:
+ - "consensus/beacon/consensus.go"
+ - title: "Legacy OP-mainnet / OP-goerli header-verification support"
+ description: |
+ Pre-Bedrock OP-mainnet and OP-Goerli had differently formatted block-headers, loosely compatible with the geth types (since it was based on Clique).
+ However, due to differences like the extra-data length (97+ bytes), these legacy block-headers need special verification.
+ The pre-merge "consensus" fallback is set to this custom but basic verifier, to accept these headers when syncing a pre-bedrock part of the chain,
+ independent of any clique code or configuration (which may be removed from geth at a later point).
+ All the custom verifier has to do is accept the headers, as the headers are already verified by block-hash through the reverse-header-sync.
+ globs:
+ - "consensus/beacon/oplegacy.go"
+ - title: "Engine API modifications"
+ description: |
+ The Engine API is extended to insert transactions into the block and optionally exclude the tx-pool,
+ to reproduce the exact block of the sequencer from just the inputs, as derived from L1 by the rollup-node.
+ See [L2 execution engine specs](https://github.com/ethereum-optimism/optimism/blob/develop/specs/exec-engine.md).
+ globs:
+ - "beacon/engine/types.go"
+ - "beacon/engine/gen_blockparams.go"
+ - "eth/catalyst/api.go"
+ - title: "Block-building modifications"
+ description: |
+ The block-building code (in the "miner" package because of Proof-Of-Work legacy of ethereum) implements the
+ changes to support the transaction-inclusion, tx-pool toggle and gaslimit parameters of the Engine API.
+ globs:
+ - "miner/*"
+ - title: "Tx-pool tx cost updates"
+ description: |
+ Transaction queueing and inclusion needs to account for the L1 cost component.
+ globs:
+ - "core/txpool/**/*"
+ - "core/txpool/legacypool/*"
+ - title: "Chain Configuration"
+ sub:
+ - title: "Chain config"
+ description: |
+ The rollup functionality is enabled with the `optimism` field in the chain config.
+ The EIP-1559 parameters are configurable to adjust for faster more frequent and smaller blocks.
+ The parameters can be overriden for testing.
+ globs:
+ - "params/config.go"
+ - "params/protocol_params.go"
+ - "core/genesis.go"
+ - title: "Chain config cleanup"
+ description: |
+ The optimism Goerli testnet used clique-config data to make geth internals accept blocks.
+ Post-bedrock the beacon-consensus (i.e. follow Engine API) is now used, and the clique config is removed.
+ globs:
+ - "core/rawdb/accessors_metadata.go"
+ - title: Genesis loading
+ globs:
+ - "core/gen_genesis.go"
+ - title: "Superchain config"
+ description: Testing of the superchain configuration
+ globs:
+ - "core/superchain.go"
+ - "params/superchain.go"
+ - title: "Node modifications"
+ description: Changes to the node configuration and services.
+ sub:
+ - title: "CLI"
+ sub:
+ - title: "Flags"
+ description: |
+ Flag changes:
+ - Transactions can be forwarded to an RPC for sequencing.
+ - Historical calls can be forwarded to a legacy node.
+ - The tx pool propagation can be enabled/disabled.
+ - The Optimism bedrock fork activation can be changed for testing.
+ globs:
+ - "cmd/utils/flags.go"
+ - "cmd/geth/main.go"
+ - "internal/flags/categories.go"
+ - "cmd/geth/config.go"
+ - title: "Versioning"
+ description: List the op-geth and upstream go-ethereum versions.
+ globs:
+ - "cmd/geth/misccmd.go"
+ - "params/version.go"
+ - "build/ci.go"
+ - title: Node config
+ globs:
+ - "eth/ethconfig/config.go"
+ - title: Tx gossip disable option
+ globs:
+ - "eth/handler.go"
+ - "eth/handler_eth.go"
+ - title: Warn on missing hardfork data
+ globs:
+ - "core/blockchain.go"
+ - title: Optional Engine API extensions
+ globs:
+ - "eth/catalyst/superchain.go"
+ - title: Support legacy DBs when snap-syncing
+ description: Snap-sync does not serve unprefixed code by default.
+ globs:
+ - "core/blockchain_reader.go"
+ - "eth/protocols/snap/handler.go"
+ - title: Historical data for Snap-sync
+ description: Snap-sync has access to trusted Deposit Transaction Nonce Data.
+ globs:
+ - "eth/downloader/downloader.go"
+ - "eth/downloader/receiptreference.go"
+ - title: Discv5 node discovery
+ description: Fix discv5 option to allow discv5 to be an active source for node-discovery.
+ globs:
+ - "p2p/server.go"
+ - title: Bootnodes
+ description: Discovery bootnode addresses.
+ globs:
+ - "params/bootnodes.go"
+ - title: Generated TOML config update
+ globs:
+ - "eth/ethconfig/gen_config.go"
+ - title: "User API enhancements"
+ description: "Encode the Deposit Tx properties, the L1 costs, and daisy-chain RPC-calls for pre-Bedrock historical data"
+ sub:
+ - title: "Receipts metadata"
+ description: |
+ Pre-Bedrock L1-cost receipt data is loaded from the database if available, and post-Bedrock the L1-cost
+ metadata is hydrated on-the-fly based on the L1 fee information in the corresponding block.
+ globs:
+ - "core/types/receipt.go"
+ - "core/types/gen_receipt_json.go"
+ - "core/rawdb/accessors_chain.go"
+ - title: "API Backend"
+ description: |
+ Forward transactions to the sequencer if configured.
+ globs:
+ - "eth/api_backend.go"
+ - "eth/backend.go"
+ - "internal/ethapi/backend.go"
+ - title: "Apply L1 cost in API responses"
+ globs:
+ - "eth/state_accessor.go"
+ - title: API frontend
+ description: Format deposit and L1-cost data in transaction responses. Add `debug_chainConfig` API.
+ globs:
+ - "internal/ethapi/api.go"
+ - "rpc/errors.go"
+ - title: Tracer RPC daisy-chain
+ description: Forward pre-bedrock tracing calls to legacy node.
+ globs:
+ - "eth/tracers/api.go"
+ - title: "Daisy Chain tests"
+ ignore:
+ - "internal/ethapi/transaction_args_test.go"
+ - "ethclient/ethclient_test.go"
+ - "eth/tracers/api_test.go"
+ - title: Debug API
+ description: Fix Debug API block marshaling to include deposits
+ globs:
+ - "eth/api_debug.go"
+ - title: Eth gasprice suggestions
+ description: gasprice suggestion adjustments to accommodate faster L2 blocks and lower fees.
+ globs:
+ - "eth/gasprice/gasprice.go"
+ - "eth/gasprice/optimism-gasprice.go"
+ - title: API testvector fix
+ description: |
+ Upstream test of broken behavior; in Optimism, a zero signature is valid (pre-bedrock for deposit-txs),
+ and the chain ID formula on signature data must not be used, or an underflow happens.
+ globs:
+ - "internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json"
+ - title: "Geth extras"
+ description: Extend the tools available in geth to improve external testing and tooling.
+ sub:
+ - title: Simulated Backend
+ globs:
+ - "accounts/abi/bind/backends/simulated.go"
+ - "ethclient/simulated/backend.go"
+ - title: "Hardware wallet support"
+ description: Extend Ledger wallet support for newer devices on Macos
+ sub:
+ - title: Fix Ledger discoverability
+ # upstream PR: https://github.com/tenderly/op-geth/pull/28863/
+ globs:
+ - "accounts/usbwallet/hub.go"
+ - title: "Testing"
+ description: Additional or modified tests, not already captured by the above diff
+ ignore:
+ - "**/*_test.go"
+
+# ignored globally, does not count towards line count
+ignore:
+ - ".circleci/*"
+ - "*.sum"
+ - "go.mod"
+ - "fork.yaml"
+ - "Makefile"
+ - ".golangci.yml"
+ - ".github/**"
+ - "**/*.gob" # data asset, not code
+ - "core/vm/testdata/precompiles/p256Verify.json" # data asset, not code
+ - "eth/tracers/internal/tracetest/testdata/**/*.json"
diff --git go-ethereum/go.mod op-geth/go.mod
index 7a54b1ff7ca902bb92f91baf6308f851f6e7aa89..e93d5428fe5f4d10009bdad2510fe7e8478714cf 100644
--- go-ethereum/go.mod
+++ op-geth/go.mod
@@ -1,6 +1,8 @@
-module github.com/ethereum/go-ethereum
+module github.com/tenderly/op-geth
-go 1.20
+go 1.21
+
+toolchain go1.21.6
require (
github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.2.0
@@ -20,7 +22,9 @@ github.com/crate-crypto/go-kzg-4844 v0.7.0
github.com/davecgh/go-spew v1.1.1
github.com/deckarep/golang-set/v2 v2.1.0
github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127
+ github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20240522134500-19555bdbdc95
github.com/ethereum/c-kzg-4844 v0.4.0
+ github.com/ethereum/go-ethereum v1.10.26
github.com/fatih/color v1.13.0
github.com/ferranbt/fastssz v0.1.2
github.com/fjl/gencodec v0.0.0-20230517082657-f9840df7b83e
@@ -63,7 +67,7 @@ github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
github.com/tyler-smith/go-bip39 v1.1.0
github.com/urfave/cli/v2 v2.25.7
go.uber.org/automaxprocs v1.5.2
- golang.org/x/crypto v0.17.0
+ golang.org/x/crypto v0.18.0
golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa
golang.org/x/sync v0.5.0
golang.org/x/sys v0.16.0
@@ -99,7 +103,7 @@ github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect
github.com/consensys/bavard v0.1.13 // indirect
github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect
- github.com/deepmap/oapi-codegen v1.6.0 // indirect
+ github.com/deepmap/oapi-codegen v1.8.2 // indirect
github.com/dlclark/regexp2 v1.7.0 // indirect
github.com/garslo/gogen v0.0.0-20170306192744-1d203ffc1f61 // indirect
github.com/go-ole/go-ole v1.3.0 // indirect
@@ -111,7 +115,7 @@ github.com/google/go-querystring v1.1.0 // indirect
github.com/google/pprof v0.0.0-20230207041349-798e818bf904 // indirect
github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
github.com/hashicorp/go-retryablehttp v0.7.4 // indirect
- github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839 // indirect
+ github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect
github.com/jmespath/go-jmespath v0.4.0 // indirect
github.com/kilic/bls12-381 v0.1.0 // indirect
github.com/klauspost/compress v1.15.15 // indirect
@@ -133,8 +137,9 @@ github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a // indirect
github.com/prometheus/common v0.32.1 // indirect
github.com/prometheus/procfs v0.7.3 // indirect
github.com/rivo/uniseg v0.2.0 // indirect
- github.com/rogpeppe/go-internal v1.9.0 // indirect
+ github.com/rogpeppe/go-internal v1.10.0 // indirect
github.com/russross/blackfriday/v2 v2.1.0 // indirect
+ github.com/stretchr/objx v0.5.0 // indirect
github.com/tklauser/go-sysconf v0.3.12 // indirect
github.com/tklauser/numcpus v0.6.1 // indirect
github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
@@ -144,3 +149,5 @@ google.golang.org/protobuf v1.27.1 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
rsc.io/tmplfunc v0.0.3 // indirect
)
+
+//replace github.com/ethereum-optimism/superchain-registry/superchain => ../superchain-registry/superchain
diff --git go-ethereum/go.sum op-geth/go.sum
index bb4ded5c2ff7632cc07b48a7ac2ee75df0325bb1..6c9db775d717c002de878ed79c491806d06e9185 100644
--- go-ethereum/go.sum
+++ op-geth/go.sum
@@ -35,14 +35,18 @@ github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.0 h1:8q4SaHjFsClSvuVne0ID/5Ka8u3fcIHyqkLjcFpNRHQ=
github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.0/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q=
github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.3.0 h1:vcYCAze6p19qBW7MhZybIsqD8sMV8js0NyQM8JDnVtg=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.3.0/go.mod h1:OQeznEEkTZ9OrhHJoDD8ZDq51FHgXjqtP9z6bEwBq9U=
github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0 h1:sXr+ck84g/ZlZUOZiNELInmMgOsuGwdjjVkEIde0OtY=
github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0/go.mod h1:okt5dMMTOFjX/aovMlrjvvXoPMBVSPzk9185BT0+eZM=
github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.2.0 h1:Ma67P/GGprNwsslzEH6+Kb8nybI8jpDTm4Wmzu2ReK8=
+github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.2.0/go.mod h1:c+Lifp3EDEamAkPVzMooRNOK6CZjNSdEnf1A7jsI9u4=
github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.2.0 h1:gggzg0SUMs6SQbEw+3LoSsYf9YMjkupeAnHMX8O9mmY=
github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.2.0/go.mod h1:+6KLcKIVgxoBDMqMO/Nvy7bZ9a0nbU3I1DtFQK3YvB4=
github.com/AzureAD/microsoft-authentication-library-for-go v1.0.0 h1:OBhqkivkhkMqLPymWEppkm7vgPQY2XsHoEkaMQ0AdZY=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.0.0/go.mod h1:kgDmCTgBzIEPFElEF+FK0SdjAor06dRq2Go927dnQ6o=
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
+github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
github.com/CloudyKit/fastprinter v0.0.0-20170127035650-74b38d55f37a/go.mod h1:EFZQ978U7x8IRnstaskI3IysnWY5Ao3QgZUKOXlsAdw=
github.com/CloudyKit/jet v2.1.3-0.20180809161101-62edd43e4f88+incompatible/go.mod h1:HPYO+50pSWkPoj9Q/eq0aRGByCL6ScRlUmiEX5Zgm+w=
@@ -102,6 +106,7 @@ github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
github.com/btcsuite/btcd/btcec/v2 v2.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k=
github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU=
github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s=
@@ -121,6 +126,7 @@ github.com/cloudflare/cloudflare-go v0.79.0/go.mod h1:gkHQf9xEubaQPEuerBuoinR9P8bf8a05Lq0X6WKy1Oc=
github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
github.com/cockroachdb/datadriven v1.0.0/go.mod h1:5Ib8Meh+jk1RlHIXej6Pzevx/NLlNvQB9pmSBZErGA4=
github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4=
+github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU=
github.com/cockroachdb/errors v1.6.1/go.mod h1:tm6FTP5G81vwJ5lC0SizQo374JNCOPrHyXGitRJoDqM=
github.com/cockroachdb/errors v1.8.1 h1:A5+txlVZfOqFBDa4mGz2bUWSp0aHElvHX2bKkdbQu+Y=
github.com/cockroachdb/errors v1.8.1/go.mod h1:qGwQn6JmZ+oMjuLwjWzUNqblqk0xl4CVV3SQbGwK7Ac=
@@ -160,8 +166,9 @@ github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0=
github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc=
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
-github.com/deepmap/oapi-codegen v1.6.0 h1:w/d1ntwh91XI0b/8ja7+u5SvA4IFfM0UNNLmiDR1gg0=
github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M=
+github.com/deepmap/oapi-codegen v1.8.2 h1:SegyeYGcdi0jLLrpbCMoJxnUUn8GBXHsvr4rbzjuhfU=
+github.com/deepmap/oapi-codegen v1.8.2/go.mod h1:YLgSKSDv/bZQB7N4ws6luhozi3cEdRktEqrX88CvjIw=
github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4=
github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
@@ -169,6 +176,7 @@ github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
github.com/dlclark/regexp2 v1.7.0 h1:7lJfhqlPssTb1WQx4yvTHN0uElPEv52sbaECrAQxjAo=
github.com/dlclark/regexp2 v1.7.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
github.com/dnaeon/go-vcr v1.2.0 h1:zHCHvJYTMh1N7xnV7zf1m1GPBF9Ad0Jk/whtQ1663qI=
+github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ=
github.com/dop251/goja v0.0.0-20211022113120-dc8c55024d06/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=
github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127 h1:qwcF+vdFrvPSEUDSX5RVoRccG8a5DhOdWdQ4zN62zzo=
github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127/go.mod h1:QMWlm50DNe14hD7t24KEqZuUdC9sOTy8W6XbCU1mlw4=
@@ -181,8 +189,12 @@ github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
+github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20240522134500-19555bdbdc95 h1:GjXKQg6u6WkEIcY0dvW2IKhMRY8cVjwdw+rNKhduAo8=
+github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20240522134500-19555bdbdc95/go.mod h1:7xh2awFQqsiZxFrHKTgEd+InVfDRrkKVUIuK8SAFHp0=
github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY=
github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
+github.com/ethereum/go-ethereum v1.10.26 h1:i/7d9RBBwiXCEuyduBQzJw/mKmnvzsN14jqBmytw72s=
+github.com/ethereum/go-ethereum v1.10.26/go.mod h1:EYFyF19u3ezGLD4RqOkLq+ZCXzYbLoNDdZlMt7kyKFg=
github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8=
github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
@@ -206,6 +218,7 @@ github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE=
github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc=
github.com/getkin/kin-openapi v0.53.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
+github.com/getkin/kin-openapi v0.61.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s=
github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM=
@@ -332,6 +345,7 @@ github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
github.com/hashicorp/go-hclog v1.2.0 h1:La19f8d7WIlm4ogzNHB0JGqs5AUDAZ2UfCY4sJXcJdM=
+github.com/hashicorp/go-hclog v1.2.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
github.com/hashicorp/go-retryablehttp v0.7.4 h1:ZQgVdpTdAL7WpMIwLzCfbalOcSUdkDZnpUv3/+BxzFA=
github.com/hashicorp/go-retryablehttp v0.7.4/go.mod h1:Jy/gPYAdjqffZ/yFGCFV2doI5wjtH1ewM9u8iYVjtX8=
github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
@@ -356,8 +370,9 @@ github.com/influxdata/influxdb-client-go/v2 v2.4.0 h1:HGBfZYStlx3Kqvsv1h2pJixbCl/jhnFtxpKFAv9Tu5k=
github.com/influxdata/influxdb-client-go/v2 v2.4.0/go.mod h1:vLNHdxTJkIf2mSLvGrpj8TCcISApPoXkaxP8g9uRlW8=
github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c h1:qSHzRbhzK8RdXOsAdfDgO49TtqC1oZ+acxPrkfTxcCs=
github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo=
-github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839 h1:W9WBk7wlPfJLvMCdtV4zPulc4uCPrlywQOmbFOhgQNU=
github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo=
+github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 h1:vilfsDSy7TDxedi9gyBkMvAirat/oRcL0lFdJBf6tdM=
+github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo=
github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI=
github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0=
github.com/iris-contrib/i18n v0.0.0-20171121225848-987a633949d0/go.mod h1:pMCz62A0xJL6I+umB2YTlFRwWXaDFA0jy+5HzGiJjqI=
@@ -422,6 +437,7 @@ github.com/labstack/echo/v4 v4.1.11/go.mod h1:i541M3Fj6f76NZtHSj7TXnyM8n2gaodfvfxNnFqi74g=
github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4FW1e6jwpg=
github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
+github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8=
github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
@@ -497,6 +513,7 @@ github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0=
github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8 h1:KoWmjvw+nsYOo29YJK9vDA65RGE3NrOnUtO7a+RF9HU=
+github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI=
github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -505,6 +522,7 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g=
+github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U=
github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
@@ -531,12 +549,14 @@ github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
github.com/protolambda/bls12-381-util v0.0.0-20220416220906-d8552aa452c7 h1:cZC+usqsYgHtlBaGulVnZ1hfKAi8iWtujBnRLQE698c=
github.com/protolambda/bls12-381-util v0.0.0-20220416220906-d8552aa452c7/go.mod h1:IToEjHuttnUzwZI5KBSM/LOOW3qLbbrHOEfp3SbECGY=
github.com/prysmaticlabs/gohashtree v0.0.1-alpha.0.20220714111606-acbb2962fb48 h1:cSo6/vk8YpvkLbk9v3FO97cakNmUoxwi2KMP8hd5WIw=
+github.com/prysmaticlabs/gohashtree v0.0.1-alpha.0.20220714111606-acbb2962fb48/go.mod h1:4pWaT30XoEx1j8KNJf3TV+E3mQkaufn7mf+jRNb/Fuk=
github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
-github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
@@ -563,11 +583,16 @@ github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA=
github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4=
@@ -623,8 +648,8 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
-golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
+golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -859,8 +884,9 @@ golang.org/x/tools v0.15.0/go.mod h1:hpksKq4dtpQWS1uQ61JkdqWM3LscIS6Slf+VVkm+wQk=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df h1:5Pf6pFKu98ODmgnpvkJ3kFUOQGGLIzLIkbzUHp47618=
+golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=